Update Boost in 3rdParty to version 1.56.0.

This updates Boost in our 3rdParty directory to version 1.56.0. Updated our update.sh script to stop on error. Changed error reporting in SwiftTools/CrashReporter.cpp to SWIFT_LOG due to missing include of <iostream> with newer Boost. Change-Id: I4b35c77de951333979a524097f35f5f83d325edc
author: Tobias Markmann <tm@ayena.de> 2014-10-19 20:22:58 (GMT)
committer: Tobias Markmann <tm@ayena.de> 2014-10-20 13:49:33 (GMT)
commit: 6b22dfcf59474dd016a0355a3102a1dd3692d92c (patch)
tree: 2b1fd33be433a91e81fee84fdc2bf1b52575d934 /3rdParty/Boost/src/boost/asio
parent: 38b0cb785fea8eae5e48fae56440695fdfd10ee1 (diff)
download: swift-6b22dfcf59474dd016a0355a3102a1dd3692d92c.zip
swift-6b22dfcf59474dd016a0355a3102a1dd3692d92c.tar.bz2
360 files changed, 13168 insertions, 3556 deletions
diff --git a/3rdParty/Boost/src/boost/asio/async_result.hpp b/3rdParty/Boost/src/boost/asio/async_result.hpp
new file mode 100644
index 0000000..7a24ce5
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/async_result.hpp
@@ -0,0 +1,96 @@
+//
+// async_result.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_ASYNC_RESULT_HPP
+#define BOOST_ASIO_ASYNC_RESULT_HPP
+
+#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/handler_type.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+
+/// An interface for customising the behaviour of an initiating function.
+/**
+ * This template may be specialised for user-defined handler types.
+ */
+template <typename Handler>
+class async_result
+{
+public:
+  /// The return type of the initiating function.
+  typedef void type;
+
+  /// Construct an async result from a given handler.
+  /**
+   * When using a specalised async_result, the constructor has an opportunity
+   * to initialise some state associated with the handler, which is then
+   * returned from the initiating function.
+   */
+  explicit async_result(Handler&)
+  {
+  }
+
+  /// Obtain the value to be returned from the initiating function.
+  type get()
+  {
+  }
+};
+
+namespace detail {
+
+// Helper template to deduce the true type of a handler, capture a local copy
+// of the handler, and then create an async_result for the handler.
+template <typename Handler, typename Signature>
+struct async_result_init
+{
+  explicit async_result_init(BOOST_ASIO_MOVE_ARG(Handler) orig_handler)
+    : handler(BOOST_ASIO_MOVE_CAST(Handler)(orig_handler)),
+      result(handler)
+  {
+  }
+
+  typename handler_type<Handler, Signature>::type handler;
+  async_result<typename handler_type<Handler, Signature>::type> result;
+};
+
+template <typename Handler, typename Signature>
+struct async_result_type_helper
+{
+  typedef typename async_result<
+      typename handler_type<Handler, Signature>::type
+    >::type type;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#if defined(GENERATING_DOCUMENTATION)
+# define BOOST_ASIO_INITFN_RESULT_TYPE(h, sig) \
+  void_or_deduced
+#elif defined(_MSC_VER) && (_MSC_VER < 1500)
+# define BOOST_ASIO_INITFN_RESULT_TYPE(h, sig) \
+  typename ::boost::asio::detail::async_result_type_helper<h, sig>::type
+#else
+# define BOOST_ASIO_INITFN_RESULT_TYPE(h, sig) \
+  typename ::boost::asio::async_result< \
+    typename ::boost::asio::handler_type<h, sig>::type>::type
+#endif
+
+#endif // BOOST_ASIO_ASYNC_RESULT_HPP
diff --git a/3rdParty/Boost/src/boost/asio/basic_datagram_socket.hpp b/3rdParty/Boost/src/boost/asio/basic_datagram_socket.hpp
index a773315..1be3c78 100644
--- a/3rdParty/Boost/src/boost/asio/basic_datagram_socket.hpp
+++ b/3rdParty/Boost/src/boost/asio/basic_datagram_socket.hpp
@@ -1,11 +1,11 @@
 //
 // basic_datagram_socket.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)
 //
 
 #ifndef BOOST_ASIO_BASIC_DATAGRAM_SOCKET_HPP
@@ -18,12 +18,13 @@
 #include <boost/asio/detail/config.hpp>
 #include <cstddef>
 #include <boost/asio/basic_socket.hpp>
 #include <boost/asio/datagram_socket_service.hpp>
 #include <boost/asio/detail/handler_type_requirements.hpp>
 #include <boost/asio/detail/throw_error.hpp>
+#include <boost/asio/detail/type_traits.hpp>
 #include <boost/asio/error.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
@@ -163,12 +164,56 @@ public:
   basic_datagram_socket& operator=(basic_datagram_socket&& other)
   {
     basic_socket<Protocol, DatagramSocketService>::operator=(
         BOOST_ASIO_MOVE_CAST(basic_datagram_socket)(other));
     return *this;
   }
+
+  /// Move-construct a basic_datagram_socket from a socket of another protocol
+  /// type.
+  /**
+   * This constructor moves a datagram socket from one object to another.
+   *
+   * @param other The other basic_datagram_socket object from which the move
+   * will occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_datagram_socket(io_service&) constructor.
+   */
+  template <typename Protocol1, typename DatagramSocketService1>
+  basic_datagram_socket(
+      basic_datagram_socket<Protocol1, DatagramSocketService1>&& other,
+      typename enable_if<is_convertible<Protocol1, Protocol>::value>::type* = 0)
+    : basic_socket<Protocol, DatagramSocketService>(
+        BOOST_ASIO_MOVE_CAST2(basic_datagram_socket<
+          Protocol1, DatagramSocketService1>)(other))
+  {
+  }
+
+  /// Move-assign a basic_datagram_socket from a socket of another protocol
+  /// type.
+  /**
+   * This assignment operator moves a datagram socket from one object to
+   * another.
+   *
+   * @param other The other basic_datagram_socket object from which the move
+   * will occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_datagram_socket(io_service&) constructor.
+   */
+  template <typename Protocol1, typename DatagramSocketService1>
+  typename enable_if<is_convertible<Protocol1, Protocol>::value,
+      basic_datagram_socket>::type& operator=(
+        basic_datagram_socket<Protocol1, DatagramSocketService1>&& other)
+  {
+    basic_socket<Protocol, DatagramSocketService>::operator=(
+        BOOST_ASIO_MOVE_CAST2(basic_datagram_socket<
+          Protocol1, DatagramSocketService1>)(other));
+    return *this;
+  }
 #endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
 
   /// Send some data on a connected socket.
   /**
    * This function is used to send data on the datagram socket. The function
    * call will block until the data has been sent successfully or an error
@@ -252,15 +297,14 @@ public:
     return this->get_service().send(
         this->get_implementation(), buffers, flags, ec);
   }
 
   /// Start an asynchronous send on a connected socket.
   /**
-   * This function is used to send data on the datagram socket. The function
-   * call will block until the data has been sent successfully or an error
-   * occurs.
+   * This function is used to asynchronously send data on the datagram socket.
+   * The function call always returns immediately.
    *
    * @param buffers One or more data buffers to be sent on the socket. Although
    * the buffers object may be copied as necessary, ownership of the underlying
    * memory blocks is retained by the caller, which must guarantee that they
    * remain valid until the handler is called.
    *
@@ -287,28 +331,29 @@ public:
    * @endcode
    * See the @ref buffer documentation for information on sending multiple
    * buffers in one go, and how to use it with arrays, boost::array or
    * std::vector.
    */
   template <typename ConstBufferSequence, typename WriteHandler>
-  void async_send(const ConstBufferSequence& buffers,
+  BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,
+      void (boost::system::error_code, std::size_t))
+  async_send(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;
 
-    this->get_service().async_send(this->get_implementation(),
+    return this->get_service().async_send(this->get_implementation(),
         buffers, 0, BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
   }
 
   /// Start an asynchronous send on a connected socket.
   /**
-   * This function is used to send data on the datagram socket. The function
-   * call will block until the data has been sent successfully or an error
-   * occurs.
+   * This function is used to asynchronously send data on the datagram socket.
+   * The function call always returns immediately.
    *
    * @param buffers One or more data buffers to be sent on the socket. Although
    * the buffers object may be copied as necessary, ownership of the underlying
    * memory blocks is retained by the caller, which must guarantee that they
    * remain valid until the handler is called.
    *
@@ -328,21 +373,23 @@ public:
    *
    * @note The async_send operation can only be used with a connected socket.
    * Use the async_send_to function to send data on an unconnected datagram
    * socket.
    */
   template <typename ConstBufferSequence, typename WriteHandler>
-  void async_send(const ConstBufferSequence& buffers,
+  BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,
+      void (boost::system::error_code, std::size_t))
+  async_send(const ConstBufferSequence& buffers,
       socket_base::message_flags flags,
       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;
 
-    this->get_service().async_send(this->get_implementation(),
+    return this->get_service().async_send(this->get_implementation(),
         buffers, flags, BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
   }
 
   /// Send a datagram to the specified endpoint.
   /**
    * This function is used to send a datagram to the specified remote endpoint.
@@ -466,22 +513,25 @@ public:
    * @endcode
    * See the @ref buffer documentation for information on sending multiple
    * buffers in one go, and how to use it with arrays, boost::array or
    * std::vector.
    */
   template <typename ConstBufferSequence, typename WriteHandler>
-  void async_send_to(const ConstBufferSequence& buffers,
+  BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,
+      void (boost::system::error_code, std::size_t))
+  async_send_to(const ConstBufferSequence& buffers,
       const endpoint_type& destination,
       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;
 
-    this->get_service().async_send_to(this->get_implementation(), buffers,
-        destination, 0, BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
+    return this->get_service().async_send_to(
+        this->get_implementation(), buffers, destination, 0,
+        BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
   }
 
   /// Start an asynchronous send.
   /**
    * This function is used to asynchronously send a datagram to the specified
    * remote endpoint. The function call always returns immediately.
@@ -506,22 +556,25 @@ public:
    * Regardless of whether the asynchronous operation completes immediately or
    * not, the handler will not be invoked from within this function. Invocation
    * of the handler will be performed in a manner equivalent to using
    * boost::asio::io_service::post().
    */
   template <typename ConstBufferSequence, typename WriteHandler>
-  void async_send_to(const ConstBufferSequence& buffers,
+  BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,
+      void (boost::system::error_code, std::size_t))
+  async_send_to(const ConstBufferSequence& buffers,
       const endpoint_type& destination, socket_base::message_flags flags,
       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;
 
-    this->get_service().async_send_to(this->get_implementation(), buffers,
-        destination, flags, BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
+    return this->get_service().async_send_to(
+        this->get_implementation(), buffers, destination, flags,
+        BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
   }
 
   /// Receive some data on a connected socket.
   /**
    * This function is used to receive data on the datagram socket. The function
    * call will block until data has been received successfully or an error
@@ -644,20 +697,22 @@ public:
    * @endcode
    * See the @ref buffer documentation for information on receiving into
    * multiple buffers in one go, and how to use it with arrays, boost::array or
    * std::vector.
    */
   template <typename MutableBufferSequence, typename ReadHandler>
-  void async_receive(const MutableBufferSequence& buffers,
+  BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+      void (boost::system::error_code, std::size_t))
+  async_receive(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;
 
-    this->get_service().async_receive(this->get_implementation(),
+    return this->get_service().async_receive(this->get_implementation(),
         buffers, 0, BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
   }
 
   /// Start an asynchronous receive on a connected socket.
   /**
    * This function is used to asynchronously receive data from the datagram
@@ -684,21 +739,23 @@ public:
    *
    * @note The async_receive operation can only be used with a connected socket.
    * Use the async_receive_from function to receive data on an unconnected
    * datagram socket.
    */
   template <typename MutableBufferSequence, typename ReadHandler>
-  void async_receive(const MutableBufferSequence& buffers,
+  BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+      void (boost::system::error_code, std::size_t))
+  async_receive(const MutableBufferSequence& buffers,
       socket_base::message_flags flags,
       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;
 
-    this->get_service().async_receive(this->get_implementation(),
+    return this->get_service().async_receive(this->get_implementation(),
         buffers, flags, BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
   }
 
   /// Receive a datagram with the endpoint of the sender.
   /**
    * This function is used to receive a datagram. The function call will block
@@ -816,28 +873,31 @@ public:
    * boost::asio::io_service::post().
    *
    * @par Example
    * To receive into a single data buffer use the @ref buffer function as
    * follows:
    * @code socket.async_receive_from(
-   *     boost::asio::buffer(data, size), 0, sender_endpoint, handler); @endcode
+   *     boost::asio::buffer(data, size), sender_endpoint, handler); @endcode
    * See the @ref buffer documentation for information on receiving into
    * multiple buffers in one go, and how to use it with arrays, boost::array or
    * std::vector.
    */
   template <typename MutableBufferSequence, typename ReadHandler>
-  void async_receive_from(const MutableBufferSequence& buffers,
+  BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+      void (boost::system::error_code, std::size_t))
+  async_receive_from(const MutableBufferSequence& buffers,
       endpoint_type& sender_endpoint,
       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;
 
-    this->get_service().async_receive_from(this->get_implementation(), buffers,
-        sender_endpoint, 0, BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
+    return this->get_service().async_receive_from(
+        this->get_implementation(), buffers, sender_endpoint, 0,
+        BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
   }
 
   /// Start an asynchronous receive.
   /**
    * This function is used to asynchronously receive a datagram. The function
    * call always returns immediately.
@@ -864,22 +924,25 @@ public:
    * Regardless of whether the asynchronous operation completes immediately or
    * not, the handler will not be invoked from within this function. Invocation
    * of the handler will be performed in a manner equivalent to using
    * boost::asio::io_service::post().
    */
   template <typename MutableBufferSequence, typename ReadHandler>
-  void async_receive_from(const MutableBufferSequence& buffers,
+  BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+      void (boost::system::error_code, std::size_t))
+  async_receive_from(const MutableBufferSequence& buffers,
       endpoint_type& sender_endpoint, socket_base::message_flags flags,
       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;
 
-    this->get_service().async_receive_from(this->get_implementation(), buffers,
-        sender_endpoint, flags, BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
+    return this->get_service().async_receive_from(
+        this->get_implementation(), buffers, sender_endpoint, flags,
+        BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
   }
 };
 
 } // namespace asio
 } // namespace boost
 
diff --git a/3rdParty/Boost/src/boost/asio/basic_deadline_timer.hpp b/3rdParty/Boost/src/boost/asio/basic_deadline_timer.hpp
index 6baeb7a..767e859 100644
--- a/3rdParty/Boost/src/boost/asio/basic_deadline_timer.hpp
+++ b/3rdParty/Boost/src/boost/asio/basic_deadline_timer.hpp
@@ -1,11 +1,11 @@
 //
 // basic_deadline_timer.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)
 //
 
 #ifndef BOOST_ASIO_BASIC_DEADLINE_TIMER_HPP
@@ -13,12 +13,16 @@
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HAS_BOOST_DATE_TIME) \
+  || defined(GENERATING_DOCUMENTATION)
+
 #include <cstddef>
 #include <boost/asio/basic_io_object.hpp>
 #include <boost/asio/deadline_timer_service.hpp>
 #include <boost/asio/detail/handler_type_requirements.hpp>
 #include <boost/asio/detail/throw_error.hpp>
 #include <boost/asio/error.hpp>
@@ -489,23 +493,28 @@ public:
    * Regardless of whether the asynchronous operation completes immediately or
    * not, the handler will not be invoked from within this function. Invocation
    * of the handler will be performed in a manner equivalent to using
    * boost::asio::io_service::post().
    */
   template <typename WaitHandler>
-  void async_wait(BOOST_ASIO_MOVE_ARG(WaitHandler) handler)
+  BOOST_ASIO_INITFN_RESULT_TYPE(WaitHandler,
+      void (boost::system::error_code))
+  async_wait(BOOST_ASIO_MOVE_ARG(WaitHandler) handler)
   {
     // If you get an error on the following line it means that your handler does
     // not meet the documented type requirements for a WaitHandler.
     BOOST_ASIO_WAIT_HANDLER_CHECK(WaitHandler, handler) type_check;
 
-    this->service.async_wait(this->implementation,
+    return this->service.async_wait(this->implementation,
         BOOST_ASIO_MOVE_CAST(WaitHandler)(handler));
   }
 };
 
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
+#endif // defined(BOOST_ASIO_HAS_BOOST_DATE_TIME)
+       // || defined(GENERATING_DOCUMENTATION)
+
 #endif // BOOST_ASIO_BASIC_DEADLINE_TIMER_HPP
diff --git a/3rdParty/Boost/src/boost/asio/basic_io_object.hpp b/3rdParty/Boost/src/boost/asio/basic_io_object.hpp
index 0464335..784fcc9 100644
--- a/3rdParty/Boost/src/boost/asio/basic_io_object.hpp
+++ b/3rdParty/Boost/src/boost/asio/basic_io_object.hpp
@@ -1,11 +1,11 @@
 //
 // basic_io_object.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)
 //
 
 #ifndef BOOST_ASIO_BASIC_IO_OBJECT_HPP
diff --git a/3rdParty/Boost/src/boost/asio/basic_raw_socket.hpp b/3rdParty/Boost/src/boost/asio/basic_raw_socket.hpp
index 90f66c0..4f3c7c2 100644
--- a/3rdParty/Boost/src/boost/asio/basic_raw_socket.hpp
+++ b/3rdParty/Boost/src/boost/asio/basic_raw_socket.hpp
@@ -1,11 +1,11 @@
 //
 // basic_raw_socket.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)
 //
 
 #ifndef BOOST_ASIO_BASIC_RAW_SOCKET_HPP
@@ -17,12 +17,13 @@
 
 #include <boost/asio/detail/config.hpp>
 #include <cstddef>
 #include <boost/asio/basic_socket.hpp>
 #include <boost/asio/detail/handler_type_requirements.hpp>
 #include <boost/asio/detail/throw_error.hpp>
+#include <boost/asio/detail/type_traits.hpp>
 #include <boost/asio/error.hpp>
 #include <boost/asio/raw_socket_service.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
@@ -162,12 +163,52 @@ public:
   basic_raw_socket& operator=(basic_raw_socket&& other)
   {
     basic_socket<Protocol, RawSocketService>::operator=(
         BOOST_ASIO_MOVE_CAST(basic_raw_socket)(other));
     return *this;
   }
+
+  /// Move-construct a basic_raw_socket from a socket of another protocol type.
+  /**
+   * This constructor moves a raw socket from one object to another.
+   *
+   * @param other The other basic_raw_socket object from which the move will
+   * occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_raw_socket(io_service&) constructor.
+   */
+  template <typename Protocol1, typename RawSocketService1>
+  basic_raw_socket(basic_raw_socket<Protocol1, RawSocketService1>&& other,
+      typename enable_if<is_convertible<Protocol1, Protocol>::value>::type* = 0)
+    : basic_socket<Protocol, RawSocketService>(
+        BOOST_ASIO_MOVE_CAST2(basic_raw_socket<
+          Protocol1, RawSocketService1>)(other))
+  {
+  }
+
+  /// Move-assign a basic_raw_socket from a socket of another protocol type.
+  /**
+   * This assignment operator moves a raw socket from one object to another.
+   *
+   * @param other The other basic_raw_socket object from which the move
+   * will occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_raw_socket(io_service&) constructor.
+   */
+  template <typename Protocol1, typename RawSocketService1>
+  typename enable_if<is_convertible<Protocol1, Protocol>::value,
+      basic_raw_socket>::type& operator=(
+        basic_raw_socket<Protocol1, RawSocketService1>&& other)
+  {
+    basic_socket<Protocol, RawSocketService>::operator=(
+        BOOST_ASIO_MOVE_CAST2(basic_raw_socket<
+          Protocol1, RawSocketService1>)(other));
+    return *this;
+  }
 #endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
 
   /// Send some data on a connected socket.
   /**
    * This function is used to send data on the raw socket. The function call
    * will block until the data has been sent successfully or an error occurs.
@@ -282,20 +323,22 @@ public:
    * @endcode
    * See the @ref buffer documentation for information on sending multiple
    * buffers in one go, and how to use it with arrays, boost::array or
    * std::vector.
    */
   template <typename ConstBufferSequence, typename WriteHandler>
-  void async_send(const ConstBufferSequence& buffers,
+  BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,
+      void (boost::system::error_code, std::size_t))
+  async_send(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;
 
-    this->get_service().async_send(this->get_implementation(),
+    return this->get_service().async_send(this->get_implementation(),
         buffers, 0, BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
   }
 
   /// Start an asynchronous send on a connected socket.
   /**
    * This function is used to send data on the raw socket. The function call
@@ -322,21 +365,23 @@ public:
    *
    * @note The async_send operation can only be used with a connected socket.
    * Use the async_send_to function to send data on an unconnected raw
    * socket.
    */
   template <typename ConstBufferSequence, typename WriteHandler>
-  void async_send(const ConstBufferSequence& buffers,
+  BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,
+      void (boost::system::error_code, std::size_t))
+  async_send(const ConstBufferSequence& buffers,
       socket_base::message_flags flags,
       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;
 
-    this->get_service().async_send(this->get_implementation(),
+    return this->get_service().async_send(this->get_implementation(),
         buffers, flags, BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
   }
 
   /// Send raw data to the specified endpoint.
   /**
    * This function is used to send raw data to the specified remote endpoint.
@@ -460,22 +505,24 @@ public:
    * @endcode
    * See the @ref buffer documentation for information on sending multiple
    * buffers in one go, and how to use it with arrays, boost::array or
    * std::vector.
    */
   template <typename ConstBufferSequence, typename WriteHandler>
-  void async_send_to(const ConstBufferSequence& buffers,
+  BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,
+      void (boost::system::error_code, std::size_t))
+  async_send_to(const ConstBufferSequence& buffers,
       const endpoint_type& destination,
       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;
 
-    this->get_service().async_send_to(this->get_implementation(), buffers,
-        destination, 0, BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
+    return this->get_service().async_send_to(this->get_implementation(),
+        buffers, destination, 0, BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
   }
 
   /// Start an asynchronous send.
   /**
    * This function is used to asynchronously send raw data to the specified
    * remote endpoint. The function call always returns immediately.
@@ -500,22 +547,25 @@ public:
    * Regardless of whether the asynchronous operation completes immediately or
    * not, the handler will not be invoked from within this function. Invocation
    * of the handler will be performed in a manner equivalent to using
    * boost::asio::io_service::post().
    */
   template <typename ConstBufferSequence, typename WriteHandler>
-  void async_send_to(const ConstBufferSequence& buffers,
+  BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,
+      void (boost::system::error_code, std::size_t))
+  async_send_to(const ConstBufferSequence& buffers,
       const endpoint_type& destination, socket_base::message_flags flags,
       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;
 
-    this->get_service().async_send_to(this->get_implementation(), buffers,
-        destination, flags, BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
+    return this->get_service().async_send_to(
+        this->get_implementation(), buffers, destination, flags,
+        BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
   }
 
   /// Receive some data on a connected socket.
   /**
    * This function is used to receive data on the raw socket. The function
    * call will block until data has been received successfully or an error
@@ -638,20 +688,22 @@ public:
    * @endcode
    * See the @ref buffer documentation for information on receiving into
    * multiple buffers in one go, and how to use it with arrays, boost::array or
    * std::vector.
    */
   template <typename MutableBufferSequence, typename ReadHandler>
-  void async_receive(const MutableBufferSequence& buffers,
+  BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+      void (boost::system::error_code, std::size_t))
+  async_receive(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;
 
-    this->get_service().async_receive(this->get_implementation(),
+    return this->get_service().async_receive(this->get_implementation(),
         buffers, 0, BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
   }
 
   /// Start an asynchronous receive on a connected socket.
   /**
    * This function is used to asynchronously receive data from the raw
@@ -678,21 +730,23 @@ public:
    *
    * @note The async_receive operation can only be used with a connected socket.
    * Use the async_receive_from function to receive data on an unconnected
    * raw socket.
    */
   template <typename MutableBufferSequence, typename ReadHandler>
-  void async_receive(const MutableBufferSequence& buffers,
+  BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+      void (boost::system::error_code, std::size_t))
+  async_receive(const MutableBufferSequence& buffers,
       socket_base::message_flags flags,
       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;
 
-    this->get_service().async_receive(this->get_implementation(),
+    return this->get_service().async_receive(this->get_implementation(),
         buffers, flags, BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
   }
 
   /// Receive raw data with the endpoint of the sender.
   /**
    * This function is used to receive raw data. The function call will block
@@ -816,22 +870,25 @@ public:
    *     boost::asio::buffer(data, size), 0, sender_endpoint, handler); @endcode
    * See the @ref buffer documentation for information on receiving into
    * multiple buffers in one go, and how to use it with arrays, boost::array or
    * std::vector.
    */
   template <typename MutableBufferSequence, typename ReadHandler>
-  void async_receive_from(const MutableBufferSequence& buffers,
+  BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+      void (boost::system::error_code, std::size_t))
+  async_receive_from(const MutableBufferSequence& buffers,
       endpoint_type& sender_endpoint,
       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;
 
-    this->get_service().async_receive_from(this->get_implementation(), buffers,
-        sender_endpoint, 0, BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
+    return this->get_service().async_receive_from(
+        this->get_implementation(), buffers, sender_endpoint, 0,
+        BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
   }
 
   /// Start an asynchronous receive.
   /**
    * This function is used to asynchronously receive raw data. The function
    * call always returns immediately.
@@ -858,22 +915,25 @@ public:
    * Regardless of whether the asynchronous operation completes immediately or
    * not, the handler will not be invoked from within this function. Invocation
    * of the handler will be performed in a manner equivalent to using
    * boost::asio::io_service::post().
    */
   template <typename MutableBufferSequence, typename ReadHandler>
-  void async_receive_from(const MutableBufferSequence& buffers,
+  BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+      void (boost::system::error_code, std::size_t))
+  async_receive_from(const MutableBufferSequence& buffers,
       endpoint_type& sender_endpoint, socket_base::message_flags flags,
       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;
 
-    this->get_service().async_receive_from(this->get_implementation(), buffers,
-        sender_endpoint, flags, BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
+    return this->get_service().async_receive_from(
+        this->get_implementation(), buffers, sender_endpoint, flags,
+        BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
   }
 };
 
 } // namespace asio
 } // namespace boost
 
diff --git a/3rdParty/Boost/src/boost/asio/basic_seq_packet_socket.hpp b/3rdParty/Boost/src/boost/asio/basic_seq_packet_socket.hpp
index a638c71..630296c 100644
--- a/3rdParty/Boost/src/boost/asio/basic_seq_packet_socket.hpp
+++ b/3rdParty/Boost/src/boost/asio/basic_seq_packet_socket.hpp
@@ -1,11 +1,11 @@
 //
 // basic_seq_packet_socket.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)
 //
 
 #ifndef BOOST_ASIO_BASIC_SEQ_PACKET_SOCKET_HPP
@@ -168,12 +168,57 @@ public:
   basic_seq_packet_socket& operator=(basic_seq_packet_socket&& other)
   {
     basic_socket<Protocol, SeqPacketSocketService>::operator=(
         BOOST_ASIO_MOVE_CAST(basic_seq_packet_socket)(other));
     return *this;
   }
+
+  /// Move-construct a basic_seq_packet_socket from a socket of another protocol
+  /// type.
+  /**
+   * This constructor moves a sequenced packet socket from one object to
+   * another.
+   *
+   * @param other The other basic_seq_packet_socket object from which the move
+   * will occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_seq_packet_socket(io_service&) constructor.
+   */
+  template <typename Protocol1, typename SeqPacketSocketService1>
+  basic_seq_packet_socket(
+      basic_seq_packet_socket<Protocol1, SeqPacketSocketService1>&& other,
+      typename enable_if<is_convertible<Protocol1, Protocol>::value>::type* = 0)
+    : basic_socket<Protocol, SeqPacketSocketService>(
+        BOOST_ASIO_MOVE_CAST2(basic_seq_packet_socket<
+          Protocol1, SeqPacketSocketService1>)(other))
+  {
+  }
+
+  /// Move-assign a basic_seq_packet_socket from a socket of another protocol
+  /// type.
+  /**
+   * This assignment operator moves a sequenced packet socket from one object to
+   * another.
+   *
+   * @param other The other basic_seq_packet_socket object from which the move
+   * will occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_seq_packet_socket(io_service&) constructor.
+   */
+  template <typename Protocol1, typename SeqPacketSocketService1>
+  typename enable_if<is_convertible<Protocol1, Protocol>::value,
+      basic_seq_packet_socket>::type& operator=(
+        basic_seq_packet_socket<Protocol1, SeqPacketSocketService1>&& other)
+  {
+    basic_socket<Protocol, SeqPacketSocketService>::operator=(
+        BOOST_ASIO_MOVE_CAST2(basic_seq_packet_socket<
+          Protocol1, SeqPacketSocketService1>)(other));
+    return *this;
+  }
 #endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
 
   /// Send some data on the socket.
   /**
    * This function is used to send data on the sequenced packet socket. The
    * function call will block until the data has been sent successfully, or an
@@ -264,21 +309,23 @@ public:
    * @endcode
    * See the @ref buffer documentation for information on sending multiple
    * buffers in one go, and how to use it with arrays, boost::array or
    * std::vector.
    */
   template <typename ConstBufferSequence, typename WriteHandler>
-  void async_send(const ConstBufferSequence& buffers,
+  BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,
+      void (boost::system::error_code, std::size_t))
+  async_send(const ConstBufferSequence& buffers,
       socket_base::message_flags flags,
       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;
 
-    this->get_service().async_send(this->get_implementation(),
+    return this->get_service().async_send(this->get_implementation(),
         buffers, flags, BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
   }
 
   /// Receive some data on the socket.
   /**
    * This function is used to receive data on the sequenced packet socket. The
@@ -434,22 +481,25 @@ public:
    * @endcode
    * See the @ref buffer documentation for information on receiving into
    * multiple buffers in one go, and how to use it with arrays, boost::array or
    * std::vector.
    */
   template <typename MutableBufferSequence, typename ReadHandler>
-  void async_receive(const MutableBufferSequence& buffers,
+  BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+      void (boost::system::error_code, std::size_t))
+  async_receive(const MutableBufferSequence& buffers,
       socket_base::message_flags& out_flags,
       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;
 
-    this->get_service().async_receive(this->get_implementation(), buffers,
-        0, out_flags, BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
+    return this->get_service().async_receive(
+        this->get_implementation(), buffers, 0, out_flags,
+        BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
   }
 
   /// Start an asynchronous receive.
   /**
    * This function is used to asynchronously receive data from the sequenced
    * data socket. The function call always returns immediately.
@@ -489,23 +539,26 @@ public:
    * @endcode
    * See the @ref buffer documentation for information on receiving into
    * multiple buffers in one go, and how to use it with arrays, boost::array or
    * std::vector.
    */
   template <typename MutableBufferSequence, typename ReadHandler>
-  void async_receive(const MutableBufferSequence& buffers,
+  BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+      void (boost::system::error_code, std::size_t))
+  async_receive(const MutableBufferSequence& buffers,
       socket_base::message_flags in_flags,
       socket_base::message_flags& out_flags,
       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;
 
-    this->get_service().async_receive(this->get_implementation(), buffers,
-        in_flags, out_flags, BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
+    return this->get_service().async_receive(
+        this->get_implementation(), buffers, in_flags, out_flags,
+        BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
   }
 };
 
 } // namespace asio
 } // namespace boost
 
diff --git a/3rdParty/Boost/src/boost/asio/basic_serial_port.hpp b/3rdParty/Boost/src/boost/asio/basic_serial_port.hpp
index 31ee955..dda2c88 100644
--- a/3rdParty/Boost/src/boost/asio/basic_serial_port.hpp
+++ b/3rdParty/Boost/src/boost/asio/basic_serial_port.hpp
@@ -1,11 +1,11 @@
 //
 // basic_serial_port.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
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 //
 
@@ -556,20 +556,22 @@ public:
    * @endcode
    * See the @ref buffer documentation for information on writing multiple
    * buffers in one go, and how to use it with arrays, boost::array or
    * std::vector.
    */
   template <typename ConstBufferSequence, typename WriteHandler>
-  void async_write_some(const ConstBufferSequence& buffers,
+  BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,
+      void (boost::system::error_code, std::size_t))
+  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;
 
-    this->get_service().async_write_some(this->get_implementation(),
+    return this->get_service().async_write_some(this->get_implementation(),
         buffers, BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
   }
 
   /// Read some data from the serial port.
   /**
    * This function is used to read data from the serial port. The function
@@ -667,20 +669,22 @@ public:
    * @endcode
    * See the @ref buffer documentation for information on reading into multiple
    * buffers in one go, and how to use it with arrays, boost::array or
    * std::vector.
    */
   template <typename MutableBufferSequence, typename ReadHandler>
-  void async_read_some(const MutableBufferSequence& buffers,
+  BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+      void (boost::system::error_code, std::size_t))
+  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;
 
-    this->get_service().async_read_some(this->get_implementation(),
+    return this->get_service().async_read_some(this->get_implementation(),
         buffers, BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
   }
 };
 
 } // namespace asio
 } // namespace boost
diff --git a/3rdParty/Boost/src/boost/asio/basic_signal_set.hpp b/3rdParty/Boost/src/boost/asio/basic_signal_set.hpp
index ddbef87..d7f60fa 100644
--- a/3rdParty/Boost/src/boost/asio/basic_signal_set.hpp
+++ b/3rdParty/Boost/src/boost/asio/basic_signal_set.hpp
@@ -1,11 +1,11 @@
 //
 // basic_signal_set.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)
 //
 
 #ifndef BOOST_ASIO_BASIC_SIGNAL_SET_HPP
@@ -362,19 +362,21 @@ public:
    * Regardless of whether the asynchronous operation completes immediately or
    * not, the handler will not be invoked from within this function. Invocation
    * of the handler will be performed in a manner equivalent to using
    * boost::asio::io_service::post().
    */
   template <typename SignalHandler>
-  void async_wait(BOOST_ASIO_MOVE_ARG(SignalHandler) handler)
+  BOOST_ASIO_INITFN_RESULT_TYPE(SignalHandler,
+      void (boost::system::error_code, int))
+  async_wait(BOOST_ASIO_MOVE_ARG(SignalHandler) handler)
   {
     // If you get an error on the following line it means that your handler does
     // not meet the documented type requirements for a SignalHandler.
     BOOST_ASIO_SIGNAL_HANDLER_CHECK(SignalHandler, handler) type_check;
 
-    this->service.async_wait(this->implementation,
+    return this->service.async_wait(this->implementation,
         BOOST_ASIO_MOVE_CAST(SignalHandler)(handler));
   }
 };
 
 } // namespace asio
 } // namespace boost
diff --git a/3rdParty/Boost/src/boost/asio/basic_socket.hpp b/3rdParty/Boost/src/boost/asio/basic_socket.hpp
index c9e2045..a28f365 100644
--- a/3rdParty/Boost/src/boost/asio/basic_socket.hpp
+++ b/3rdParty/Boost/src/boost/asio/basic_socket.hpp
@@ -1,11 +1,11 @@
 //
 // basic_socket.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)
 //
 
 #ifndef BOOST_ASIO_BASIC_SOCKET_HPP
@@ -13,15 +13,17 @@
 
 #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/async_result.hpp>
 #include <boost/asio/basic_io_object.hpp>
 #include <boost/asio/detail/handler_type_requirements.hpp>
 #include <boost/asio/detail/throw_error.hpp>
+#include <boost/asio/detail/type_traits.hpp>
 #include <boost/asio/error.hpp>
 #include <boost/asio/socket_base.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
@@ -170,12 +172,57 @@ public:
   basic_socket& operator=(basic_socket&& other)
   {
     basic_io_object<SocketService>::operator=(
         BOOST_ASIO_MOVE_CAST(basic_socket)(other));
     return *this;
   }
+
+  // All sockets have access to each other's implementations.
+  template <typename Protocol1, typename SocketService1>
+  friend class basic_socket;
+
+  /// Move-construct a basic_socket from a socket of another protocol type.
+  /**
+   * This constructor moves a socket from one object to another.
+   *
+   * @param other The other basic_socket object from which the move will
+   * occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_socket(io_service&) constructor.
+   */
+  template <typename Protocol1, typename SocketService1>
+  basic_socket(basic_socket<Protocol1, SocketService1>&& other,
+      typename enable_if<is_convertible<Protocol1, Protocol>::value>::type* = 0)
+    : basic_io_object<SocketService>(other.get_io_service())
+  {
+    this->get_service().template converting_move_construct<Protocol1>(
+        this->get_implementation(), other.get_implementation());
+  }
+
+  /// Move-assign a basic_socket from a socket of another protocol type.
+  /**
+   * This assignment operator moves a socket from one object to another.
+   *
+   * @param other The other basic_socket object from which the move will
+   * occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_socket(io_service&) constructor.
+   */
+  template <typename Protocol1, typename SocketService1>
+  typename enable_if<is_convertible<Protocol1, Protocol>::value,
+      basic_socket>::type& operator=(
+        basic_socket<Protocol1, SocketService1>&& other)
+  {
+    basic_socket tmp(BOOST_ASIO_MOVE_CAST2(basic_socket<
+            Protocol1, SocketService1>)(other));
+    basic_io_object<SocketService>::operator=(
+        BOOST_ASIO_MOVE_CAST(basic_socket)(tmp));
+    return *this;
+  }
 #endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
 
   /// Get a reference to the lowest layer.
   /**
    * This function returns a reference to the lowest layer in a stack of
    * layers. Since a basic_socket cannot contain any further layers, it simply
@@ -392,13 +439,13 @@ public:
    * operations and close the socket.
    *
    * When running on Windows Vista, Windows Server 2008, and later, the
    * CancelIoEx function is always used. This function does not have the
    * problems described above.
    */
-#if defined(BOOST_MSVC) && (BOOST_MSVC >= 1400) \
+#if defined(BOOST_ASIO_MSVC) && (BOOST_ASIO_MSVC >= 1400) \
   && (!defined(_WIN32_WINNT) || _WIN32_WINNT < 0x0600) \
   && !defined(BOOST_ASIO_ENABLE_CANCELIO)
   __declspec(deprecated("By default, this function always fails with "
         "operation_not_supported when used on Windows XP, Windows Server 2003, "
         "or earlier. Consult documentation for details."))
 #endif
@@ -440,13 +487,13 @@ public:
    * operations and close the socket.
    *
    * When running on Windows Vista, Windows Server 2008, and later, the
    * CancelIoEx function is always used. This function does not have the
    * problems described above.
    */
-#if defined(BOOST_MSVC) && (BOOST_MSVC >= 1400) \
+#if defined(BOOST_ASIO_MSVC) && (BOOST_ASIO_MSVC >= 1400) \
   && (!defined(_WIN32_WINNT) || _WIN32_WINNT < 0x0600) \
   && !defined(BOOST_ASIO_ENABLE_CANCELIO)
   __declspec(deprecated("By default, this function always fails with "
         "operation_not_supported when used on Windows XP, Windows Server 2003, "
         "or earlier. Consult documentation for details."))
 #endif
@@ -695,33 +742,42 @@ public:
    * boost::asio::ip::tcp::endpoint endpoint(
    *     boost::asio::ip::address::from_string("1.2.3.4"), 12345);
    * socket.async_connect(endpoint, connect_handler);
    * @endcode
    */
   template <typename ConnectHandler>
-  void async_connect(const endpoint_type& peer_endpoint,
+  BOOST_ASIO_INITFN_RESULT_TYPE(ConnectHandler,
+      void (boost::system::error_code))
+  async_connect(const endpoint_type& peer_endpoint,
       BOOST_ASIO_MOVE_ARG(ConnectHandler) handler)
   {
     // If you get an error on the following line it means that your handler does
     // not meet the documented type requirements for a ConnectHandler.
     BOOST_ASIO_CONNECT_HANDLER_CHECK(ConnectHandler, handler) type_check;
 
     if (!is_open())
     {
       boost::system::error_code ec;
       const protocol_type protocol = peer_endpoint.protocol();
       if (this->get_service().open(this->get_implementation(), protocol, ec))
       {
+        detail::async_result_init<
+          ConnectHandler, void (boost::system::error_code)> init(
+            BOOST_ASIO_MOVE_CAST(ConnectHandler)(handler));
+
         this->get_io_service().post(
             boost::asio::detail::bind_handler(
-              BOOST_ASIO_MOVE_CAST(ConnectHandler)(handler), ec));
-        return;
+              BOOST_ASIO_MOVE_CAST(BOOST_ASIO_HANDLER_TYPE(
+                ConnectHandler, void (boost::system::error_code)))(
+                  init.handler), ec));
+
+        return init.result.get();
       }
     }
 
-    this->get_service().async_connect(this->get_implementation(),
+    return this->get_service().async_connect(this->get_implementation(),
         peer_endpoint, BOOST_ASIO_MOVE_CAST(ConnectHandler)(handler));
   }
 
   /// Set an option on the socket.
   /**
    * This function is used to set an option on the socket.
@@ -840,13 +896,13 @@ public:
    * Getting the value of the SOL_SOCKET/SO_KEEPALIVE option:
    * @code
    * boost::asio::ip::tcp::socket socket(io_service);
    * ...
    * boost::asio::ip::tcp::socket::keep_alive option;
    * socket.get_option(option);
-   * bool is_set = option.get();
+   * bool is_set = option.value();
    * @endcode
    */
   template <typename GettableSocketOption>
   void get_option(GettableSocketOption& option) const
   {
     boost::system::error_code ec;
@@ -888,13 +944,13 @@ public:
    * boost::system::error_code ec;
    * socket.get_option(option, ec);
    * if (ec)
    * {
    *   // An error occurred.
    * }
-   * bool is_set = option.get();
+   * bool is_set = option.value();
    * @endcode
    */
   template <typename GettableSocketOption>
   boost::system::error_code get_option(GettableSocketOption& option,
       boost::system::error_code& ec) const
   {
diff --git a/3rdParty/Boost/src/boost/asio/basic_socket_acceptor.hpp b/3rdParty/Boost/src/boost/asio/basic_socket_acceptor.hpp
index 5a3b0f7..ed019a0 100644
--- a/3rdParty/Boost/src/boost/asio/basic_socket_acceptor.hpp
+++ b/3rdParty/Boost/src/boost/asio/basic_socket_acceptor.hpp
@@ -1,11 +1,11 @@
 //
 // basic_socket_acceptor.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)
 //
 
 #ifndef BOOST_ASIO_BASIC_SOCKET_ACCEPTOR_HPP
@@ -17,12 +17,13 @@
 
 #include <boost/asio/detail/config.hpp>
 #include <boost/asio/basic_io_object.hpp>
 #include <boost/asio/basic_socket.hpp>
 #include <boost/asio/detail/handler_type_requirements.hpp>
 #include <boost/asio/detail/throw_error.hpp>
+#include <boost/asio/detail/type_traits.hpp>
 #include <boost/asio/error.hpp>
 #include <boost/asio/socket_acceptor_service.hpp>
 #include <boost/asio/socket_base.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
@@ -208,12 +209,60 @@ public:
   basic_socket_acceptor& operator=(basic_socket_acceptor&& other)
   {
     basic_io_object<SocketAcceptorService>::operator=(
         BOOST_ASIO_MOVE_CAST(basic_socket_acceptor)(other));
     return *this;
   }
+
+  // All socket acceptors have access to each other's implementations.
+  template <typename Protocol1, typename SocketAcceptorService1>
+  friend class basic_socket_acceptor;
+
+  /// Move-construct a basic_socket_acceptor from an acceptor of another
+  /// protocol type.
+  /**
+   * This constructor moves an acceptor from one object to another.
+   *
+   * @param other The other basic_socket_acceptor object from which the move
+   * will occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_socket(io_service&) constructor.
+   */
+  template <typename Protocol1, typename SocketAcceptorService1>
+  basic_socket_acceptor(
+      basic_socket_acceptor<Protocol1, SocketAcceptorService1>&& other,
+      typename enable_if<is_convertible<Protocol1, Protocol>::value>::type* = 0)
+    : basic_io_object<SocketAcceptorService>(other.get_io_service())
+  {
+    this->get_service().template converting_move_construct<Protocol1>(
+        this->get_implementation(), other.get_implementation());
+  }
+
+  /// Move-assign a basic_socket_acceptor from an acceptor of another protocol
+  /// type.
+  /**
+   * This assignment operator moves an acceptor from one object to another.
+   *
+   * @param other The other basic_socket_acceptor object from which the move
+   * will occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_socket(io_service&) constructor.
+   */
+  template <typename Protocol1, typename SocketAcceptorService1>
+  typename enable_if<is_convertible<Protocol1, Protocol>::value,
+      basic_socket_acceptor>::type& operator=(
+        basic_socket_acceptor<Protocol1, SocketAcceptorService1>&& other)
+  {
+    basic_socket_acceptor tmp(BOOST_ASIO_MOVE_CAST2(basic_socket_acceptor<
+            Protocol1, SocketAcceptorService1>)(other));
+    basic_io_object<SocketAcceptorService>::operator=(
+        BOOST_ASIO_MOVE_CAST(basic_socket_acceptor)(tmp));
+    return *this;
+  }
 #endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
 
   /// Open the acceptor using the specified protocol.
   /**
    * This function opens the socket acceptor so that it will use the specified
    * protocol.
@@ -313,14 +362,15 @@ public:
    *
    * @throws boost::system::system_error Thrown on failure.
    *
    * @par Example
    * @code
    * boost::asio::ip::tcp::acceptor acceptor(io_service);
-   * acceptor.open(boost::asio::ip::tcp::v4());
-   * acceptor.bind(boost::asio::ip::tcp::endpoint(12345));
+   * boost::asio::ip::tcp::endpoint endpoint(boost::asio::ip::tcp::v4(), 12345);
+   * acceptor.open(endpoint.protocol());
+   * acceptor.bind(endpoint);
    * @endcode
    */
   void bind(const endpoint_type& endpoint)
   {
     boost::system::error_code ec;
     this->get_service().bind(this->get_implementation(), endpoint, ec);
@@ -337,15 +387,16 @@ public:
    *
    * @param ec Set to indicate what error occurred, if any.
    *
    * @par Example
    * @code
    * boost::asio::ip::tcp::acceptor acceptor(io_service);
-   * acceptor.open(boost::asio::ip::tcp::v4());
+   * boost::asio::ip::tcp::endpoint endpoint(boost::asio::ip::tcp::v4(), 12345);
+   * acceptor.open(endpoint.protocol());
    * boost::system::error_code ec;
-   * acceptor.bind(boost::asio::ip::tcp::endpoint(12345), ec);
+   * acceptor.bind(endpoint, ec);
    * if (ec)
    * {
    *   // An error occurred.
    * }
    * @endcode
    */
@@ -868,17 +919,19 @@ public:
    * boost::asio::ip::tcp::acceptor acceptor(io_service);
    * ...
    * boost::asio::ip::tcp::socket socket(io_service);
    * acceptor.accept(socket);
    * @endcode
    */
-  template <typename SocketService>
-  void accept(basic_socket<protocol_type, SocketService>& peer)
+  template <typename Protocol1, typename SocketService>
+  void accept(basic_socket<Protocol1, SocketService>& peer,
+      typename enable_if<is_convertible<Protocol, Protocol1>::value>::type* = 0)
   {
     boost::system::error_code ec;
-    this->get_service().accept(this->get_implementation(), peer, 0, ec);
+    this->get_service().accept(this->get_implementation(),
+        peer, static_cast<endpoint_type*>(0), ec);
     boost::asio::detail::throw_error(ec, "accept");
   }
 
   /// Accept a new connection.
   /**
    * This function is used to accept a new connection from a peer into the
@@ -899,18 +952,20 @@ public:
    * if (ec)
    * {
    *   // An error occurred.
    * }
    * @endcode
    */
-  template <typename SocketService>
+  template <typename Protocol1, typename SocketService>
   boost::system::error_code accept(
-      basic_socket<protocol_type, SocketService>& peer,
-      boost::system::error_code& ec)
+      basic_socket<Protocol1, SocketService>& peer,
+      boost::system::error_code& ec,
+      typename enable_if<is_convertible<Protocol, Protocol1>::value>::type* = 0)
   {
-    return this->get_service().accept(this->get_implementation(), peer, 0, ec);
+    return this->get_service().accept(this->get_implementation(),
+        peer, static_cast<endpoint_type*>(0), ec);
   }
 
   /// Start an asynchronous accept.
   /**
    * This function is used to asynchronously accept a new connection into a
    * socket. The function call always returns immediately.
@@ -945,22 +1000,26 @@ public:
    * boost::asio::ip::tcp::acceptor acceptor(io_service);
    * ...
    * boost::asio::ip::tcp::socket socket(io_service);
    * acceptor.async_accept(socket, accept_handler);
    * @endcode
    */
-  template <typename SocketService, typename AcceptHandler>
-  void async_accept(basic_socket<protocol_type, SocketService>& peer,
-      BOOST_ASIO_MOVE_ARG(AcceptHandler) handler)
+  template <typename Protocol1, typename SocketService, typename AcceptHandler>
+  BOOST_ASIO_INITFN_RESULT_TYPE(AcceptHandler,
+      void (boost::system::error_code))
+  async_accept(basic_socket<Protocol1, SocketService>& peer,
+      BOOST_ASIO_MOVE_ARG(AcceptHandler) handler,
+      typename enable_if<is_convertible<Protocol, Protocol1>::value>::type* = 0)
   {
     // If you get an error on the following line it means that your handler does
     // not meet the documented type requirements for a AcceptHandler.
     BOOST_ASIO_ACCEPT_HANDLER_CHECK(AcceptHandler, handler) type_check;
 
-    this->get_service().async_accept(this->get_implementation(),
-        peer, 0, BOOST_ASIO_MOVE_CAST(AcceptHandler)(handler));
+    return this->get_service().async_accept(this->get_implementation(),
+        peer, static_cast<endpoint_type*>(0),
+        BOOST_ASIO_MOVE_CAST(AcceptHandler)(handler));
   }
 
   /// Accept a new connection and obtain the endpoint of the peer
   /**
    * This function is used to accept a new connection from a peer into the
    * given socket, and additionally provide the endpoint of the remote peer.
@@ -1054,20 +1113,22 @@ public:
    * Regardless of whether the asynchronous operation completes immediately or
    * not, the handler will not be invoked from within this function. Invocation
    * of the handler will be performed in a manner equivalent to using
    * boost::asio::io_service::post().
    */
   template <typename SocketService, typename AcceptHandler>
-  void async_accept(basic_socket<protocol_type, SocketService>& peer,
+  BOOST_ASIO_INITFN_RESULT_TYPE(AcceptHandler,
+      void (boost::system::error_code))
+  async_accept(basic_socket<protocol_type, SocketService>& peer,
       endpoint_type& peer_endpoint, BOOST_ASIO_MOVE_ARG(AcceptHandler) handler)
   {
     // If you get an error on the following line it means that your handler does
     // not meet the documented type requirements for a AcceptHandler.
     BOOST_ASIO_ACCEPT_HANDLER_CHECK(AcceptHandler, handler) type_check;
 
-    this->get_service().async_accept(this->get_implementation(), peer,
+    return this->get_service().async_accept(this->get_implementation(), peer,
         &peer_endpoint, BOOST_ASIO_MOVE_CAST(AcceptHandler)(handler));
   }
 };
 
 } // namespace asio
 } // namespace boost
diff --git a/3rdParty/Boost/src/boost/asio/basic_socket_iostream.hpp b/3rdParty/Boost/src/boost/asio/basic_socket_iostream.hpp
index 6fae085..221de7f 100644
--- a/3rdParty/Boost/src/boost/asio/basic_socket_iostream.hpp
+++ b/3rdParty/Boost/src/boost/asio/basic_socket_iostream.hpp
@@ -1,11 +1,11 @@
 //
 // basic_socket_iostream.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)
 //
 
 #ifndef BOOST_ASIO_BASIC_SOCKET_IOSTREAM_HPP
@@ -14,50 +14,46 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
-#if !defined(BOOST_NO_IOSTREAM)
+#if !defined(BOOST_ASIO_NO_IOSTREAM)
 
-#include <boost/utility/base_from_member.hpp>
+#include <istream>
+#include <ostream>
 #include <boost/asio/basic_socket_streambuf.hpp>
 #include <boost/asio/stream_socket_service.hpp>
 
 #if !defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
 
-# include <boost/preprocessor/arithmetic/inc.hpp>
-# include <boost/preprocessor/repetition/enum_binary_params.hpp>
-# include <boost/preprocessor/repetition/enum_params.hpp>
-# include <boost/preprocessor/repetition/repeat_from_to.hpp>
-
-# if !defined(BOOST_ASIO_SOCKET_IOSTREAM_MAX_ARITY)
-#  define BOOST_ASIO_SOCKET_IOSTREAM_MAX_ARITY 5
-# endif // !defined(BOOST_ASIO_SOCKET_IOSTREAM_MAX_ARITY)
+# include <boost/asio/detail/variadic_templates.hpp>
 
 // A macro that should expand to:
 //   template <typename T1, ..., typename Tn>
 //   explicit basic_socket_iostream(T1 x1, ..., Tn xn)
-//     : basic_iostream<char>(&this->boost::base_from_member<
-//         basic_socket_streambuf<Protocol, StreamSocketService,
-//           Time, TimeTraits, TimerService> >::member)
+//     : std::basic_iostream<char>(
+//         &this->detail::socket_iostream_base<
+//           Protocol, StreamSocketService, Time,
+//           TimeTraits, TimerService>::streambuf_)
 //   {
 //     if (rdbuf()->connect(x1, ..., xn) == 0)
 //       this->setstate(std::ios_base::failbit);
 //   }
 // This macro should only persist within this file.
 
-# define BOOST_ASIO_PRIVATE_CTR_DEF(z, n, data) \
-  template <BOOST_PP_ENUM_PARAMS(n, typename T)> \
-  explicit basic_socket_iostream(BOOST_PP_ENUM_BINARY_PARAMS(n, T, x)) \
-    : std::basic_iostream<char>(&this->boost::base_from_member< \
-        basic_socket_streambuf<Protocol, StreamSocketService, \
-          Time, TimeTraits, TimerService> >::member) \
+# define BOOST_ASIO_PRIVATE_CTR_DEF(n) \
+  template <BOOST_ASIO_VARIADIC_TPARAMS(n)> \
+  explicit basic_socket_iostream(BOOST_ASIO_VARIADIC_PARAMS(n)) \
+    : std::basic_iostream<char>( \
+        &this->detail::socket_iostream_base< \
+          Protocol, StreamSocketService, Time, \
+          TimeTraits, TimerService>::streambuf_) \
   { \
     this->setf(std::ios_base::unitbuf); \
-    if (rdbuf()->connect(BOOST_PP_ENUM_PARAMS(n, x)) == 0) \
+    if (rdbuf()->connect(BOOST_ASIO_VARIADIC_ARGS(n)) == 0) \
       this->setstate(std::ios_base::failbit); \
   } \
   /**/
 
 // A macro that should expand to:
 //   template <typename T1, ..., typename Tn>
@@ -65,55 +61,90 @@
 //   {
 //     if (rdbuf()->connect(x1, ..., xn) == 0)
 //       this->setstate(std::ios_base::failbit);
 //   }
 // This macro should only persist within this file.
 
-# define BOOST_ASIO_PRIVATE_CONNECT_DEF(z, n, data) \
-  template <BOOST_PP_ENUM_PARAMS(n, typename T)> \
-  void connect(BOOST_PP_ENUM_BINARY_PARAMS(n, T, x)) \
+# define BOOST_ASIO_PRIVATE_CONNECT_DEF(n) \
+  template <BOOST_ASIO_VARIADIC_TPARAMS(n)> \
+  void connect(BOOST_ASIO_VARIADIC_PARAMS(n)) \
   { \
-    if (rdbuf()->connect(BOOST_PP_ENUM_PARAMS(n, x)) == 0) \
+    if (rdbuf()->connect(BOOST_ASIO_VARIADIC_ARGS(n)) == 0) \
       this->setstate(std::ios_base::failbit); \
   } \
   /**/
 
 #endif // !defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
+namespace detail {
+
+// A separate base class is used to ensure that the streambuf is initialised
+// prior to the basic_socket_iostream's basic_iostream base class.
+template <typename Protocol, typename StreamSocketService,
+    typename Time, typename TimeTraits, typename TimerService>
+class socket_iostream_base
+{
+protected:
+  basic_socket_streambuf<Protocol, StreamSocketService,
+    Time, TimeTraits, TimerService> streambuf_;
+};
+
+}
 
 /// Iostream interface for a socket.
 template <typename Protocol,
     typename StreamSocketService = stream_socket_service<Protocol>,
+#if defined(BOOST_ASIO_HAS_BOOST_DATE_TIME) \
+  || defined(GENERATING_DOCUMENTATION)
     typename Time = boost::posix_time::ptime,
     typename TimeTraits = boost::asio::time_traits<Time>,
     typename TimerService = deadline_timer_service<Time, TimeTraits> >
+#else
+    typename Time = steady_timer::clock_type,
+    typename TimeTraits = steady_timer::traits_type,
+    typename TimerService = steady_timer::service_type>
+#endif
 class basic_socket_iostream
-  : public boost::base_from_member<
-      basic_socket_streambuf<Protocol, StreamSocketService,
-        Time, TimeTraits, TimerService> >,
+  : private detail::socket_iostream_base<Protocol,
+        StreamSocketService, Time, TimeTraits, TimerService>,
     public std::basic_iostream<char>
 {
+private:
+  // These typedefs are intended keep this class's implementation independent
+  // of whether it's using Boost.DateTime, Boost.Chrono or std::chrono.
+#if defined(BOOST_ASIO_HAS_BOOST_DATE_TIME)
+  typedef TimeTraits traits_helper;
+#else
+  typedef detail::chrono_time_traits<Time, TimeTraits> traits_helper;
+#endif
+
 public:
   /// The endpoint type.
   typedef typename Protocol::endpoint endpoint_type;
 
+#if defined(GENERATING_DOCUMENTATION)
   /// The time type.
   typedef typename TimeTraits::time_type time_type;
 
   /// The duration type.
   typedef typename TimeTraits::duration_type duration_type;
+#else
+  typedef typename traits_helper::time_type time_type;
+  typedef typename traits_helper::duration_type duration_type;
+#endif
 
   /// Construct a basic_socket_iostream without establishing a connection.
   basic_socket_iostream()
-    : std::basic_iostream<char>(&this->boost::base_from_member<
-        basic_socket_streambuf<Protocol, StreamSocketService,
-          Time, TimeTraits, TimerService> >::member)
+    : std::basic_iostream<char>(
+        &this->detail::socket_iostream_base<
+          Protocol, StreamSocketService, Time,
+          TimeTraits, TimerService>::streambuf_)
   {
     this->setf(std::ios_base::unitbuf);
   }
 
 #if defined(GENERATING_DOCUMENTATION)
   /// Establish a connection to an endpoint corresponding to a resolver query.
@@ -124,24 +155,23 @@ public:
    */
   template <typename T1, ..., typename TN>
   explicit basic_socket_iostream(T1 t1, ..., TN tn);
 #elif defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
   template <typename... T>
   explicit basic_socket_iostream(T... x)
-    : std::basic_iostream<char>(&this->boost::base_from_member<
-        basic_socket_streambuf<Protocol, StreamSocketService,
-          Time, TimeTraits, TimerService> >::member)
+    : std::basic_iostream<char>(
+        &this->detail::socket_iostream_base<
+          Protocol, StreamSocketService, Time,
+          TimeTraits, TimerService>::streambuf_)
   {
     this->setf(std::ios_base::unitbuf);
     if (rdbuf()->connect(x...) == 0)
       this->setstate(std::ios_base::failbit);
   }
 #else
-  BOOST_PP_REPEAT_FROM_TO(
-      1, BOOST_PP_INC(BOOST_ASIO_SOCKET_IOSTREAM_MAX_ARITY),
-      BOOST_ASIO_PRIVATE_CTR_DEF, _ )
+  BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_CTR_DEF)
 #endif
 
 #if defined(GENERATING_DOCUMENTATION)
   /// Establish a connection to an endpoint corresponding to a resolver query.
   /**
    * This function automatically establishes a connection based on the supplied
@@ -155,15 +185,13 @@ public:
   void connect(T... x)
   {
     if (rdbuf()->connect(x...) == 0)
       this->setstate(std::ios_base::failbit);
   }
 #else
-  BOOST_PP_REPEAT_FROM_TO(
-      1, BOOST_PP_INC(BOOST_ASIO_SOCKET_IOSTREAM_MAX_ARITY),
-      BOOST_ASIO_PRIVATE_CONNECT_DEF, _ )
+  BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_CONNECT_DEF)
 #endif
 
   /// Close the connection.
   void close()
   {
     if (rdbuf()->close() == 0)
@@ -173,15 +201,15 @@ public:
   /// Return a pointer to the underlying streambuf.
   basic_socket_streambuf<Protocol, StreamSocketService,
     Time, TimeTraits, TimerService>* rdbuf() const
   {
     return const_cast<basic_socket_streambuf<Protocol, StreamSocketService,
       Time, TimeTraits, TimerService>*>(
-        &this->boost::base_from_member<
-          basic_socket_streambuf<Protocol, StreamSocketService,
-            Time, TimeTraits, TimerService> >::member);
+        &this->detail::socket_iostream_base<
+          Protocol, StreamSocketService, Time,
+          TimeTraits, TimerService>::streambuf_);
   }
 
   /// Get the last error associated with the stream.
   /**
    * @return An \c error_code corresponding to the last error from the stream.
    *
@@ -252,9 +280,9 @@ public:
 
 #if !defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
 # undef BOOST_ASIO_PRIVATE_CTR_DEF
 # undef BOOST_ASIO_PRIVATE_CONNECT_DEF
 #endif // !defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
 
-#endif // defined(BOOST_NO_IOSTREAM)
+#endif // !defined(BOOST_ASIO_NO_IOSTREAM)
 
 #endif // BOOST_ASIO_BASIC_SOCKET_IOSTREAM_HPP
diff --git a/3rdParty/Boost/src/boost/asio/basic_socket_streambuf.hpp b/3rdParty/Boost/src/boost/asio/basic_socket_streambuf.hpp
index fb047c6..d5e056d 100644
--- a/3rdParty/Boost/src/boost/asio/basic_socket_streambuf.hpp
+++ b/3rdParty/Boost/src/boost/asio/basic_socket_streambuf.hpp
@@ -1,11 +1,11 @@
 //
 // basic_socket_streambuf.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)
 //
 
 #ifndef BOOST_ASIO_BASIC_SOCKET_STREAMBUF_HPP
@@ -14,38 +14,31 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
-#if !defined(BOOST_NO_IOSTREAM)
+#if !defined(BOOST_ASIO_NO_IOSTREAM)
 
 #include <streambuf>
-#include <boost/utility/base_from_member.hpp>
 #include <boost/asio/basic_socket.hpp>
 #include <boost/asio/deadline_timer_service.hpp>
 #include <boost/asio/detail/array.hpp>
 #include <boost/asio/detail/throw_error.hpp>
 #include <boost/asio/io_service.hpp>
 #include <boost/asio/stream_socket_service.hpp>
-#include <boost/asio/time_traits.hpp>
 
-#include <boost/asio/detail/push_options.hpp>
-#include <boost/date_time/posix_time/posix_time_types.hpp>
-#include <boost/asio/detail/pop_options.hpp>
+#if defined(BOOST_ASIO_HAS_BOOST_DATE_TIME)
+# include <boost/asio/deadline_timer.hpp>
+#else
+# include <boost/asio/steady_timer.hpp>
+#endif
 
 #if !defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
 
-# include <boost/preprocessor/arithmetic/inc.hpp>
-# include <boost/preprocessor/repetition/enum_binary_params.hpp>
-# include <boost/preprocessor/repetition/enum_params.hpp>
-# include <boost/preprocessor/repetition/repeat_from_to.hpp>
-
-# if !defined(BOOST_ASIO_SOCKET_STREAMBUF_MAX_ARITY)
-#  define BOOST_ASIO_SOCKET_STREAMBUF_MAX_ARITY 5
-# endif // !defined(BOOST_ASIO_SOCKET_STREAMBUF_MAX_ARITY)
+# include <boost/asio/detail/variadic_templates.hpp>
 
 // A macro that should expand to:
 //   template <typename T1, ..., typename Tn>
 //   basic_socket_streambuf<Protocol, StreamSocketService,
 //     Time, TimeTraits, TimerService>* connect(
 //       T1 x1, ..., Tn xn)
@@ -57,60 +50,91 @@
 //     resolver_query query(x1, ..., xn);
 //     resolve_and_connect(query);
 //     return !ec_ ? this : 0;
 //   }
 // This macro should only persist within this file.
 
-# define BOOST_ASIO_PRIVATE_CONNECT_DEF( z, n, data ) \
-  template <BOOST_PP_ENUM_PARAMS(n, typename T)> \
+# define BOOST_ASIO_PRIVATE_CONNECT_DEF(n) \
+  template <BOOST_ASIO_VARIADIC_TPARAMS(n)> \
   basic_socket_streambuf<Protocol, StreamSocketService, \
-    Time, TimeTraits, TimerService>* connect( \
-      BOOST_PP_ENUM_BINARY_PARAMS(n, T, x)) \
+    Time, TimeTraits, TimerService>* connect(BOOST_ASIO_VARIADIC_PARAMS(n)) \
   { \
     init_buffers(); \
     this->basic_socket<Protocol, StreamSocketService>::close(ec_); \
     typedef typename Protocol::resolver resolver_type; \
     typedef typename resolver_type::query resolver_query; \
-    resolver_query query(BOOST_PP_ENUM_PARAMS(n, x)); \
+    resolver_query query(BOOST_ASIO_VARIADIC_ARGS(n)); \
     resolve_and_connect(query); \
     return !ec_ ? this : 0; \
   } \
   /**/
 
 #endif // !defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
+namespace detail {
+
+// A separate base class is used to ensure that the io_service is initialised
+// prior to the basic_socket_streambuf's basic_socket base class.
+class socket_streambuf_base
+{
+protected:
+  io_service io_service_;
+};
+
+} // namespace detail
 
 /// Iostream streambuf for a socket.
 template <typename Protocol,
     typename StreamSocketService = stream_socket_service<Protocol>,
+#if defined(BOOST_ASIO_HAS_BOOST_DATE_TIME) \
+  || defined(GENERATING_DOCUMENTATION)
     typename Time = boost::posix_time::ptime,
     typename TimeTraits = boost::asio::time_traits<Time>,
     typename TimerService = deadline_timer_service<Time, TimeTraits> >
+#else
+    typename Time = steady_timer::clock_type,
+    typename TimeTraits = steady_timer::traits_type,
+    typename TimerService = steady_timer::service_type>
+#endif
 class basic_socket_streambuf
   : public std::streambuf,
-    private boost::base_from_member<io_service>,
+    private detail::socket_streambuf_base,
     public basic_socket<Protocol, StreamSocketService>
 {
+private:
+  // These typedefs are intended keep this class's implementation independent
+  // of whether it's using Boost.DateTime, Boost.Chrono or std::chrono.
+#if defined(BOOST_ASIO_HAS_BOOST_DATE_TIME)
+  typedef TimeTraits traits_helper;
+#else
+  typedef detail::chrono_time_traits<Time, TimeTraits> traits_helper;
+#endif
+
 public:
   /// The endpoint type.
   typedef typename Protocol::endpoint endpoint_type;
 
+#if defined(GENERATING_DOCUMENTATION)
   /// The time type.
   typedef typename TimeTraits::time_type time_type;
 
   /// The duration type.
   typedef typename TimeTraits::duration_type duration_type;
+#else
+  typedef typename traits_helper::time_type time_type;
+  typedef typename traits_helper::duration_type duration_type;
+#endif
 
   /// Construct a basic_socket_streambuf without establishing a connection.
   basic_socket_streambuf()
     : basic_socket<Protocol, StreamSocketService>(
-        boost::base_from_member<boost::asio::io_service>::member),
+        this->detail::socket_streambuf_base::io_service_),
       unbuffered_(false),
       timer_service_(0),
       timer_state_(no_timer)
   {
     init_buffers();
   }
@@ -181,15 +205,13 @@ public:
     typedef typename resolver_type::query resolver_query;
     resolver_query query(x...);
     resolve_and_connect(query);
     return !ec_ ? this : 0;
   }
 #else
-  BOOST_PP_REPEAT_FROM_TO(
-      1, BOOST_PP_INC(BOOST_ASIO_SOCKET_STREAMBUF_MAX_ARITY),
-      BOOST_ASIO_PRIVATE_CONNECT_DEF, _ )
+  BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_CONNECT_DEF)
 #endif
 
   /// Close the connection.
   /**
    * @return \c this if a connection was successfully established, a null
    * pointer otherwise.
@@ -249,13 +271,13 @@ public:
   /// Get the stream buffer's expiry time relative to now.
   /**
    * @return A relative time value representing the stream buffer's expiry time.
    */
   duration_type expires_from_now() const
   {
-    return TimeTraits::subtract(expires_at(), TimeTraits::now());
+    return traits_helper::subtract(expires_at(), traits_helper::now());
   }
 
   /// Set the stream buffer's expiry time relative to now.
   /**
    * This function sets the expiry time associated with the stream. Stream
    * operations performed after this time (where the operations cannot be
@@ -421,14 +443,13 @@ private:
 
   template <typename ResolverQuery>
   void resolve_and_connect(const ResolverQuery& query)
   {
     typedef typename Protocol::resolver resolver_type;
     typedef typename resolver_type::iterator iterator_type;
-    resolver_type resolver(
-        boost::base_from_member<boost::asio::io_service>::member);
+    resolver_type resolver(detail::socket_streambuf_base::io_service_);
     iterator_type i = resolver.resolve(query, ec_);
     if (!ec_)
     {
       iterator_type end;
       ec_ = boost::asio::error::host_not_found;
       while (ec_ && i != end)
@@ -474,18 +495,18 @@ private:
   struct timer_handler
   {
     basic_socket_streambuf* this_;
 
     void operator()(const boost::system::error_code&)
     {
-      time_type now = TimeTraits::now();
+      time_type now = traits_helper::now();
 
       time_type expiry_time = this_->timer_service_->expires_at(
             this_->timer_implementation_);
 
-      if (TimeTraits::less_than(now, expiry_time))
+      if (traits_helper::less_than(now, expiry_time))
       {
         this_->timer_state_ = timer_is_pending;
         this_->timer_service_->async_wait(this_->timer_implementation_, *this);
       }
       else
       {
@@ -498,13 +519,13 @@ private:
 
   void construct_timer()
   {
     if (timer_service_ == 0)
     {
       TimerService& timer_service = use_service<TimerService>(
-          boost::base_from_member<boost::asio::io_service>::member);
+          detail::socket_streambuf_base::io_service_);
       timer_service.construct(timer_implementation_);
       timer_service_ = &timer_service;
     }
   }
 
   void destroy_timer()
@@ -540,9 +561,9 @@ private:
 #include <boost/asio/detail/pop_options.hpp>
 
 #if !defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
 # undef BOOST_ASIO_PRIVATE_CONNECT_DEF
 #endif // !defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
 
-#endif // !defined(BOOST_NO_IOSTREAM)
+#endif // !defined(BOOST_ASIO_NO_IOSTREAM)
 
 #endif // BOOST_ASIO_BASIC_SOCKET_STREAMBUF_HPP
diff --git a/3rdParty/Boost/src/boost/asio/basic_stream_socket.hpp b/3rdParty/Boost/src/boost/asio/basic_stream_socket.hpp
index 010f0aa..1a73c86 100644
--- a/3rdParty/Boost/src/boost/asio/basic_stream_socket.hpp
+++ b/3rdParty/Boost/src/boost/asio/basic_stream_socket.hpp
@@ -1,11 +1,11 @@
 //
 // basic_stream_socket.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)
 //
 
 #ifndef BOOST_ASIO_BASIC_STREAM_SOCKET_HPP
@@ -14,12 +14,13 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 #include <cstddef>
+#include <boost/asio/async_result.hpp>
 #include <boost/asio/basic_socket.hpp>
 #include <boost/asio/detail/handler_type_requirements.hpp>
 #include <boost/asio/detail/throw_error.hpp>
 #include <boost/asio/error.hpp>
 #include <boost/asio/stream_socket_service.hpp>
 
@@ -163,12 +164,54 @@ public:
   basic_stream_socket& operator=(basic_stream_socket&& other)
   {
     basic_socket<Protocol, StreamSocketService>::operator=(
         BOOST_ASIO_MOVE_CAST(basic_stream_socket)(other));
     return *this;
   }
+
+  /// Move-construct a basic_stream_socket from a socket of another protocol
+  /// type.
+  /**
+   * This constructor moves a stream socket from one object to another.
+   *
+   * @param other The other basic_stream_socket object from which the move
+   * will occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_stream_socket(io_service&) constructor.
+   */
+  template <typename Protocol1, typename StreamSocketService1>
+  basic_stream_socket(
+      basic_stream_socket<Protocol1, StreamSocketService1>&& other,
+      typename enable_if<is_convertible<Protocol1, Protocol>::value>::type* = 0)
+    : basic_socket<Protocol, StreamSocketService>(
+        BOOST_ASIO_MOVE_CAST2(basic_stream_socket<
+          Protocol1, StreamSocketService1>)(other))
+  {
+  }
+
+  /// Move-assign a basic_stream_socket from a socket of another protocol type.
+  /**
+   * This assignment operator moves a stream socket from one object to another.
+   *
+   * @param other The other basic_stream_socket object from which the move
+   * will occur.
+   *
+   * @note Following the move, the moved-from object is in the same state as if
+   * constructed using the @c basic_stream_socket(io_service&) constructor.
+   */
+  template <typename Protocol1, typename StreamSocketService1>
+  typename enable_if<is_convertible<Protocol1, Protocol>::value,
+      basic_stream_socket>::type& operator=(
+        basic_stream_socket<Protocol1, StreamSocketService1>&& other)
+  {
+    basic_socket<Protocol, StreamSocketService>::operator=(
+        BOOST_ASIO_MOVE_CAST2(basic_stream_socket<
+          Protocol1, StreamSocketService1>)(other));
+    return *this;
+  }
 #endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
 
   /// Send some data on the socket.
   /**
    * This function is used to send data on the stream socket. The function
    * call will block until one or more bytes of the data has been sent
@@ -300,20 +343,23 @@ public:
    * @endcode
    * See the @ref buffer documentation for information on sending multiple
    * buffers in one go, and how to use it with arrays, boost::array or
    * std::vector.
    */
   template <typename ConstBufferSequence, typename WriteHandler>
-  void async_send(const ConstBufferSequence& buffers,
+  BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,
+      void (boost::system::error_code, std::size_t))
+  async_send(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;
 
-    this->get_service().async_send(this->get_implementation(), buffers, 0,
+    return this->get_service().async_send(
+        this->get_implementation(), buffers, 0,
         BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
   }
 
   /// Start an asynchronous send.
   /**
    * This function is used to asynchronously send data on the stream socket.
@@ -349,21 +395,24 @@ public:
    * @endcode
    * See the @ref buffer documentation for information on sending multiple
    * buffers in one go, and how to use it with arrays, boost::array or
    * std::vector.
    */
   template <typename ConstBufferSequence, typename WriteHandler>
-  void async_send(const ConstBufferSequence& buffers,
+  BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,
+      void (boost::system::error_code, std::size_t))
+  async_send(const ConstBufferSequence& buffers,
       socket_base::message_flags flags,
       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;
 
-    this->get_service().async_send(this->get_implementation(), buffers, flags,
+    return this->get_service().async_send(
+        this->get_implementation(), buffers, flags,
         BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
   }
 
   /// Receive some data on the socket.
   /**
    * This function is used to receive data on the stream socket. The function
@@ -504,20 +553,22 @@ public:
    * @endcode
    * See the @ref buffer documentation for information on receiving into
    * multiple buffers in one go, and how to use it with arrays, boost::array or
    * std::vector.
    */
   template <typename MutableBufferSequence, typename ReadHandler>
-  void async_receive(const MutableBufferSequence& buffers,
+  BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+      void (boost::system::error_code, std::size_t))
+  async_receive(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;
 
-    this->get_service().async_receive(this->get_implementation(),
+    return this->get_service().async_receive(this->get_implementation(),
         buffers, 0, BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
   }
 
   /// Start an asynchronous receive.
   /**
    * This function is used to asynchronously receive data from the stream
@@ -555,21 +606,23 @@ public:
    * @endcode
    * See the @ref buffer documentation for information on receiving into
    * multiple buffers in one go, and how to use it with arrays, boost::array or
    * std::vector.
    */
   template <typename MutableBufferSequence, typename ReadHandler>
-  void async_receive(const MutableBufferSequence& buffers,
+  BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+      void (boost::system::error_code, std::size_t))
+  async_receive(const MutableBufferSequence& buffers,
       socket_base::message_flags flags,
       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;
 
-    this->get_service().async_receive(this->get_implementation(),
+    return this->get_service().async_receive(this->get_implementation(),
         buffers, flags, BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
   }
 
   /// Write some data to the socket.
   /**
    * This function is used to write data to the stream socket. The function call
@@ -663,20 +716,22 @@ public:
    * @endcode
    * See the @ref buffer documentation for information on writing multiple
    * buffers in one go, and how to use it with arrays, boost::array or
    * std::vector.
    */
   template <typename ConstBufferSequence, typename WriteHandler>
-  void async_write_some(const ConstBufferSequence& buffers,
+  BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,
+      void (boost::system::error_code, std::size_t))
+  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;
 
-    this->get_service().async_send(this->get_implementation(),
+    return this->get_service().async_send(this->get_implementation(),
         buffers, 0, BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
   }
 
   /// Read some data from the socket.
   /**
    * This function is used to read data from the stream socket. The function
@@ -774,20 +829,22 @@ public:
    * @endcode
    * See the @ref buffer documentation for information on reading into multiple
    * buffers in one go, and how to use it with arrays, boost::array or
    * std::vector.
    */
   template <typename MutableBufferSequence, typename ReadHandler>
-  void async_read_some(const MutableBufferSequence& buffers,
+  BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+      void (boost::system::error_code, std::size_t))
+  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;
 
-    this->get_service().async_receive(this->get_implementation(),
+    return this->get_service().async_receive(this->get_implementation(),
         buffers, 0, BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
   }
 };
 
 } // namespace asio
 } // namespace boost
diff --git a/3rdParty/Boost/src/boost/asio/basic_streambuf.hpp b/3rdParty/Boost/src/boost/asio/basic_streambuf.hpp
index e77624b..7884ebe 100644
--- a/3rdParty/Boost/src/boost/asio/basic_streambuf.hpp
+++ b/3rdParty/Boost/src/boost/asio/basic_streambuf.hpp
@@ -1,11 +1,11 @@
 //
 // basic_streambuf.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)
 //
 
 #ifndef BOOST_ASIO_BASIC_STREAMBUF_HPP
@@ -14,24 +14,24 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
-#if !defined(BOOST_NO_IOSTREAM)
+#if !defined(BOOST_ASIO_NO_IOSTREAM)
 
 #include <algorithm>
 #include <cstring>
 #include <stdexcept>
 #include <streambuf>
 #include <vector>
-#include <boost/limits.hpp>
-#include <boost/throw_exception.hpp>
 #include <boost/asio/basic_streambuf_fwd.hpp>
 #include <boost/asio/buffer.hpp>
+#include <boost/asio/detail/limits.hpp>
 #include <boost/asio/detail/noncopyable.hpp>
+#include <boost/asio/detail/throw_exception.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 
@@ -215,14 +215,14 @@ public:
    * sequence. The beginning of the output sequence is advanced by @c n
    * characters.
    *
    * Requires a preceding call <tt>prepare(x)</tt> where <tt>x >= n</tt>, and
    * no intervening operations that modify the input or output sequence.
    *
-   * @throws std::length_error If @c n is greater than the size of the output
-   * sequence.
+   * @note If @c n is greater than the size of the output sequence, the entire
+   * output sequence is moved to the input sequence and no error is issued.
    */
   void commit(std::size_t n)
   {
     if (pptr() + n > epptr())
       n = epptr() - pptr();
     pbump(static_cast<int>(n));
@@ -230,13 +230,14 @@ public:
   }
 
   /// Remove characters from the input sequence.
   /**
    * Removes @c n characters from the beginning of the input sequence.
    *
-   * @throws std::length_error If <tt>n > size()</tt>.
+   * @note If @c n is greater than the size of the input sequence, the entire
+   * input sequence is consumed and no error is issued.
    */
   void consume(std::size_t n)
   {
     if (egptr() < pptr())
       setg(&buffer_[0], gptr(), pptr());
     if (gptr() + n > pptr())
@@ -324,13 +325,13 @@ protected:
         pend = pnext + n;
         buffer_.resize((std::max<std::size_t>)(pend, 1));
       }
       else
       {
         std::length_error ex("boost::asio::streambuf too long");
-        boost::throw_exception(ex);
+        boost::asio::detail::throw_exception(ex);
       }
     }
 
     // Update stream positions.
     setg(&buffer_[0], &buffer_[0], &buffer_[0] + pnext);
     setp(&buffer_[0] + pnext, &buffer_[0] + pend);
@@ -362,9 +363,9 @@ inline std::size_t read_size_helper(
 
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
-#endif // !defined(BOOST_NO_IOSTREAM)
+#endif // !defined(BOOST_ASIO_NO_IOSTREAM)
 
 #endif // BOOST_ASIO_BASIC_STREAMBUF_HPP
diff --git a/3rdParty/Boost/src/boost/asio/basic_streambuf_fwd.hpp b/3rdParty/Boost/src/boost/asio/basic_streambuf_fwd.hpp
index ca806ea..87909ed 100644
--- a/3rdParty/Boost/src/boost/asio/basic_streambuf_fwd.hpp
+++ b/3rdParty/Boost/src/boost/asio/basic_streambuf_fwd.hpp
@@ -1,11 +1,11 @@
 //
 // basic_streambuf_fwd.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)
 //
 
 #ifndef BOOST_ASIO_BASIC_STREAMBUF_FWD_HPP
@@ -14,22 +14,22 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
-#if !defined(BOOST_NO_IOSTREAM)
+#if !defined(BOOST_ASIO_NO_IOSTREAM)
 
 #include <memory>
 
 namespace boost {
 namespace asio {
 
 template <typename Allocator = std::allocator<char> >
 class basic_streambuf;
 
 } // namespace asio
 } // namespace boost
 
-#endif // !defined(BOOST_NO_IOSTREAM)
+#endif // !defined(BOOST_ASIO_NO_IOSTREAM)
 
 #endif // BOOST_ASIO_BASIC_STREAMBUF_FWD_HPP
diff --git a/3rdParty/Boost/src/boost/asio/basic_waitable_timer.hpp b/3rdParty/Boost/src/boost/asio/basic_waitable_timer.hpp
index d957bde..664c1bc 100644
--- a/3rdParty/Boost/src/boost/asio/basic_waitable_timer.hpp
+++ b/3rdParty/Boost/src/boost/asio/basic_waitable_timer.hpp
@@ -1,11 +1,11 @@
 //
 // basic_waitable_timer.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)
 //
 
 #ifndef BOOST_ASIO_BASIC_WAITABLE_TIMER_HPP
@@ -35,56 +35,57 @@ namespace asio {
  * blocking or asynchronous wait for a timer to expire.
  *
  * A waitable timer is always in one of two states: "expired" or "not expired".
  * If the wait() or async_wait() function is called on an expired timer, the
  * wait operation will complete immediately.
  *
- * Most applications will use the boost::asio::waitable_timer typedef.
+ * Most applications will use one of the boost::asio::steady_timer,
+ * boost::asio::system_timer or boost::asio::high_resolution_timer typedefs.
  *
  * @note This waitable timer functionality is for use with the C++11 standard
  * library's @c &lt;chrono&gt; facility, or with the Boost.Chrono library.
  *
  * @par Thread Safety
  * @e Distinct @e objects: Safe.@n
  * @e Shared @e objects: Unsafe.
  *
  * @par Examples
- * Performing a blocking wait:
+ * Performing a blocking wait (C++11):
  * @code
  * // Construct a timer without setting an expiry time.
- * boost::asio::waitable_timer timer(io_service);
+ * boost::asio::steady_timer timer(io_service);
  *
  * // Set an expiry time relative to now.
- * timer.expires_from_now(boost::posix_time::seconds(5));
+ * timer.expires_from_now(std::chrono::seconds(5));
  *
  * // Wait for the timer to expire.
  * timer.wait();
  * @endcode
  *
  * @par 
- * Performing an asynchronous wait:
+ * Performing an asynchronous wait (C++11):
  * @code
  * void handler(const boost::system::error_code& error)
  * {
  *   if (!error)
  *   {
  *     // Timer expired.
  *   }
  * }
  *
  * ...
  *
  * // Construct a timer with an absolute expiry time.
- * boost::asio::waitable_timer timer(io_service,
- *     boost::posix_time::time_from_string("2005-12-07 23:59:59.000"));
+ * boost::asio::steady_timer timer(io_service,
+ *     std::chrono::steady_clock::now() + std::chrono::seconds(60));
  *
  * // Start an asynchronous wait.
  * timer.async_wait(handler);
  * @endcode
  *
- * @par Changing an active waitable_timer's expiry time
+ * @par Changing an active waitable timer's expiry time
  *
  * Changing the expiry time of a timer while there are pending asynchronous
  * waits causes those wait operations to be cancelled. To ensure that the action
  * associated with the timer is performed only once, use something like this:
  * used:
  *
@@ -496,19 +497,21 @@ public:
    * Regardless of whether the asynchronous operation completes immediately or
    * not, the handler will not be invoked from within this function. Invocation
    * of the handler will be performed in a manner equivalent to using
    * boost::asio::io_service::post().
    */
   template <typename WaitHandler>
-  void async_wait(BOOST_ASIO_MOVE_ARG(WaitHandler) handler)
+  BOOST_ASIO_INITFN_RESULT_TYPE(WaitHandler,
+      void (boost::system::error_code))
+  async_wait(BOOST_ASIO_MOVE_ARG(WaitHandler) handler)
   {
     // If you get an error on the following line it means that your handler does
     // not meet the documented type requirements for a WaitHandler.
     BOOST_ASIO_WAIT_HANDLER_CHECK(WaitHandler, handler) type_check;
 
-    this->service.async_wait(this->implementation,
+    return this->service.async_wait(this->implementation,
         BOOST_ASIO_MOVE_CAST(WaitHandler)(handler));
   }
 };
 
 } // namespace asio
 } // namespace boost
diff --git a/3rdParty/Boost/src/boost/asio/buffer.hpp b/3rdParty/Boost/src/boost/asio/buffer.hpp
index 532cfd1..450face 100644
--- a/3rdParty/Boost/src/boost/asio/buffer.hpp
+++ b/3rdParty/Boost/src/boost/asio/buffer.hpp
@@ -1,11 +1,11 @@
 //
 // buffer.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)
 //
 
 #ifndef BOOST_ASIO_BUFFER_HPP
@@ -17,40 +17,46 @@
 
 #include <boost/asio/detail/config.hpp>
 #include <cstddef>
 #include <cstring>
 #include <string>
 #include <vector>
-#include <boost/detail/workaround.hpp>
 #include <boost/asio/detail/array_fwd.hpp>
 
-#if defined(BOOST_MSVC)
+#if defined(BOOST_ASIO_MSVC)
 # if defined(_HAS_ITERATOR_DEBUGGING) && (_HAS_ITERATOR_DEBUGGING != 0)
 #  if !defined(BOOST_ASIO_DISABLE_BUFFER_DEBUGGING)
 #   define BOOST_ASIO_ENABLE_BUFFER_DEBUGGING
 #  endif // !defined(BOOST_ASIO_DISABLE_BUFFER_DEBUGGING)
 # endif // defined(_HAS_ITERATOR_DEBUGGING)
-#endif // defined(BOOST_MSVC)
+#endif // defined(BOOST_ASIO_MSVC)
 
 #if defined(__GNUC__)
 # if defined(_GLIBCXX_DEBUG)
 #  if !defined(BOOST_ASIO_DISABLE_BUFFER_DEBUGGING)
 #   define BOOST_ASIO_ENABLE_BUFFER_DEBUGGING
 #  endif // !defined(BOOST_ASIO_DISABLE_BUFFER_DEBUGGING)
 # endif // defined(_GLIBCXX_DEBUG)
 #endif // defined(__GNUC__)
 
 #if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)
-# include <boost/function.hpp>
+# include <boost/asio/detail/function.hpp>
 #endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING
 
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x582)) \
-  || BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590))
-# include <boost/type_traits/is_const.hpp>
-#endif // BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x582))
-       // || BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590))
+#if defined(BOOST_ASIO_HAS_BOOST_WORKAROUND)
+# include <boost/detail/workaround.hpp>
+# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x582)) \
+    || BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590))
+#  define BOOST_ASIO_ENABLE_ARRAY_BUFFER_WORKAROUND
+# endif // BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x582))
+        // || BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590))
+#endif // defined(BOOST_ASIO_HAS_BOOST_WORKAROUND)
+
+#if defined(BOOST_ASIO_ENABLE_ARRAY_BUFFER_WORKAROUND)
+# include <boost/asio/detail/type_traits.hpp>
+#endif // defined(BOOST_ASIO_ENABLE_ARRAY_BUFFER_WORKAROUND)
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 
@@ -99,20 +105,20 @@ public:
       size_(size)
   {
   }
 
 #if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)
   mutable_buffer(void* data, std::size_t size,
-      boost::function<void()> debug_check)
+      boost::asio::detail::function<void()> debug_check)
     : data_(data),
       size_(size),
       debug_check_(debug_check)
   {
   }
 
-  const boost::function<void()>& get_debug_check() const
+  const boost::asio::detail::function<void()>& get_debug_check() const
   {
     return debug_check_;
   }
 #endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING
 
 private:
@@ -122,13 +128,13 @@ private:
       const mutable_buffer& b);
 
   void* data_;
   std::size_t size_;
 
 #if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)
-  boost::function<void()> debug_check_;
+  boost::asio::detail::function<void()> debug_check_;
 #endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING
 };
 
 namespace detail {
 
 inline void* buffer_cast_helper(const mutable_buffer& b)
@@ -229,20 +235,20 @@ public:
 #endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING
   {
   }
 
 #if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)
   const_buffer(const void* data, std::size_t size,
-      boost::function<void()> debug_check)
+      boost::asio::detail::function<void()> debug_check)
     : data_(data),
       size_(size),
       debug_check_(debug_check)
   {
   }
 
-  const boost::function<void()>& get_debug_check() const
+  const boost::asio::detail::function<void()>& get_debug_check() const
   {
     return debug_check_;
   }
 #endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING
 
 private:
@@ -252,13 +258,13 @@ private:
       const const_buffer& b);
 
   const void* data_;
   std::size_t size_;
 
 #if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)
-  boost::function<void()> debug_check_;
+  boost::asio::detail::function<void()> debug_check_;
 #endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING
 };
 
 namespace detail {
 
 inline const void* buffer_cast_helper(const const_buffer& b)
@@ -509,18 +515,18 @@ public:
     : iter_(iter)
   {
   }
 
   ~buffer_debug_check()
   {
-#if BOOST_WORKAROUND(BOOST_MSVC, == 1400)
+#if defined(BOOST_ASIO_MSVC) && (BOOST_ASIO_MSVC == 1400)
     // MSVC 8's string iterator checking may crash in a std::string::iterator
     // object's destructor when the iterator points to an already-destroyed
     // std::string object, unless the iterator is cleared first.
     iter_ = Iterator();
-#endif // BOOST_WORKAROUND(BOOST_MSVC, == 1400)
+#endif // defined(BOOST_ASIO_MSVC) && (BOOST_ASIO_MSVC == 1400)
   }
 
   void operator()()
   {
     *iter_;
   }
@@ -609,12 +615,15 @@ private:
  *
  * @code vector<const_buffer> buffers = ...;
  *
  * vector<unsigned char> data(boost::asio::buffer_size(buffers));
  * boost::asio::buffer_copy(boost::asio::buffer(data), buffers); @endcode
  *
+ * Note that @ref buffer_copy is implemented in terms of @c memcpy, and
+ * consequently it cannot be used to copy between overlapping memory regions.
+ *
  * @par Buffer Invalidation
  *
  * A buffer object does not have any ownership of the memory it refers to. It
  * is the responsibility of the application to ensure the memory region remains
  * valid until it is no longer required for an I/O operation. When the memory
  * is no longer available, the buffer is said to have been invalidated.
@@ -825,14 +834,13 @@ inline const_buffers_1 buffer(const PodType (&data)[N],
   return const_buffers_1(
       const_buffer(data,
         N * sizeof(PodType) < max_size_in_bytes
         ? N * sizeof(PodType) : max_size_in_bytes));
 }
 
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x582)) \
-  || BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590))
+#if defined(BOOST_ASIO_ENABLE_ARRAY_BUFFER_WORKAROUND)
 
 // Borland C++ and Sun Studio think the overloads:
 //
 //   unspecified buffer(boost::array<PodType, N>& array ...);
 //
 // and
@@ -861,13 +869,13 @@ struct buffer_types_base<true>
   typedef const_buffer buffer_type;
   typedef const_buffers_1 container_type;
 };
 
 template <typename PodType>
 struct buffer_types
-  : public buffer_types_base<boost::is_const<PodType>::value>
+  : public buffer_types_base<is_const<PodType>::value>
 {
 };
 
 } // namespace detail
 
 template <typename PodType, std::size_t N>
@@ -893,14 +901,13 @@ buffer(boost::array<PodType, N>& data, std::size_t max_size_in_bytes)
   return container_type(
       buffer_type(data.c_array(),
         data.size() * sizeof(PodType) < max_size_in_bytes
         ? data.size() * sizeof(PodType) : max_size_in_bytes));
 }
 
-#else // BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x582))
-      // || BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590))
+#else // defined(BOOST_ASIO_ENABLE_ARRAY_BUFFER_WORKAROUND)
 
 /// Create a new modifiable buffer that represents the given POD array.
 /**
  * @returns A mutable_buffers_1 value equivalent to:
  * @code mutable_buffers_1(
  *     data.data(),
@@ -958,14 +965,13 @@ inline const_buffers_1 buffer(boost::array<const PodType, N>& data,
   return const_buffers_1(
       const_buffer(data.data(),
         data.size() * sizeof(PodType) < max_size_in_bytes
         ? data.size() * sizeof(PodType) : max_size_in_bytes));
 }
 
-#endif // BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x582))
-       // || BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590))
+#endif // defined(BOOST_ASIO_ENABLE_ARRAY_BUFFER_WORKAROUND)
 
 /// Create a new non-modifiable buffer that represents the given POD array.
 /**
  * @returns A const_buffers_1 value equivalent to:
  * @code const_buffers_1(
  *     data.data(),
@@ -1259,12 +1265,15 @@ inline const_buffers_1 buffer(
  * @li @c buffer_size(source)
  *
  * @li @c If specified, @c max_bytes_to_copy.
  *
  * This prevents buffer overflow, regardless of the buffer sizes used in the
  * copy operation.
+ *
+ * Note that @ref buffer_copy is implemented in terms of @c memcpy, and
+ * consequently it cannot be used to copy between overlapping memory regions.
  */
 /*@{*/
 
 /// Copies bytes from a source buffer to a target buffer.
 /**
  * @param target A modifiable buffer representing the memory region to which
@@ -1277,12 +1286,15 @@ inline const_buffers_1 buffer(
  *
  * @note The number of bytes copied is the lesser of:
  *
  * @li @c buffer_size(target)
  *
  * @li @c buffer_size(source)
+ *
+ * This function is implemented in terms of @c memcpy, and consequently it
+ * cannot be used to copy between overlapping memory regions.
  */
 inline std::size_t buffer_copy(const mutable_buffer& target,
     const const_buffer& source)
 {
   using namespace std; // For memcpy.
   std::size_t target_size = buffer_size(target);
@@ -1304,12 +1316,15 @@ inline std::size_t buffer_copy(const mutable_buffer& target,
  *
  * @note The number of bytes copied is the lesser of:
  *
  * @li @c buffer_size(target)
  *
  * @li @c buffer_size(source)
+ *
+ * This function is implemented in terms of @c memcpy, and consequently it
+ * cannot be used to copy between overlapping memory regions.
  */
 inline std::size_t buffer_copy(const mutable_buffer& target,
     const const_buffers_1& source)
 {
   return buffer_copy(target, static_cast<const const_buffer&>(source));
 }
@@ -1327,12 +1342,15 @@ inline std::size_t buffer_copy(const mutable_buffer& target,
  *
  * @note The number of bytes copied is the lesser of:
  *
  * @li @c buffer_size(target)
  *
  * @li @c buffer_size(source)
+ *
+ * This function is implemented in terms of @c memcpy, and consequently it
+ * cannot be used to copy between overlapping memory regions.
  */
 inline std::size_t buffer_copy(const mutable_buffer& target,
     const mutable_buffer& source)
 {
   return buffer_copy(target, const_buffer(source));
 }
@@ -1350,12 +1368,15 @@ inline std::size_t buffer_copy(const mutable_buffer& target,
  *
  * @note The number of bytes copied is the lesser of:
  *
  * @li @c buffer_size(target)
  *
  * @li @c buffer_size(source)
+ *
+ * This function is implemented in terms of @c memcpy, and consequently it
+ * cannot be used to copy between overlapping memory regions.
  */
 inline std::size_t buffer_copy(const mutable_buffer& target,
     const mutable_buffers_1& source)
 {
   return buffer_copy(target, const_buffer(source));
 }
@@ -1372,12 +1393,15 @@ inline std::size_t buffer_copy(const mutable_buffer& target,
  *
  * @note The number of bytes copied is the lesser of:
  *
  * @li @c buffer_size(target)
  *
  * @li @c buffer_size(source)
+ *
+ * This function is implemented in terms of @c memcpy, and consequently it
+ * cannot be used to copy between overlapping memory regions.
  */
 template <typename ConstBufferSequence>
 std::size_t buffer_copy(const mutable_buffer& target,
     const ConstBufferSequence& source)
 {
   std::size_t total_bytes_copied = 0;
@@ -1409,12 +1433,15 @@ std::size_t buffer_copy(const mutable_buffer& target,
  *
  * @note The number of bytes copied is the lesser of:
  *
  * @li @c buffer_size(target)
  *
  * @li @c buffer_size(source)
+ *
+ * This function is implemented in terms of @c memcpy, and consequently it
+ * cannot be used to copy between overlapping memory regions.
  */
 inline std::size_t buffer_copy(const mutable_buffers_1& target,
     const const_buffer& source)
 {
   return buffer_copy(static_cast<const mutable_buffer&>(target), source);
 }
@@ -1431,12 +1458,15 @@ inline std::size_t buffer_copy(const mutable_buffers_1& target,
  *
  * @note The number of bytes copied is the lesser of:
  *
  * @li @c buffer_size(target)
  *
  * @li @c buffer_size(source)
+ *
+ * This function is implemented in terms of @c memcpy, and consequently it
+ * cannot be used to copy between overlapping memory regions.
  */
 inline std::size_t buffer_copy(const mutable_buffers_1& target,
     const const_buffers_1& source)
 {
   return buffer_copy(static_cast<const mutable_buffer&>(target),
       static_cast<const const_buffer&>(source));
@@ -1455,12 +1485,15 @@ inline std::size_t buffer_copy(const mutable_buffers_1& target,
  *
  * @note The number of bytes copied is the lesser of:
  *
  * @li @c buffer_size(target)
  *
  * @li @c buffer_size(source)
+ *
+ * This function is implemented in terms of @c memcpy, and consequently it
+ * cannot be used to copy between overlapping memory regions.
  */
 inline std::size_t buffer_copy(const mutable_buffers_1& target,
     const mutable_buffer& source)
 {
   return buffer_copy(static_cast<const mutable_buffer&>(target),
       const_buffer(source));
@@ -1479,12 +1512,15 @@ inline std::size_t buffer_copy(const mutable_buffers_1& target,
  *
  * @note The number of bytes copied is the lesser of:
  *
  * @li @c buffer_size(target)
  *
  * @li @c buffer_size(source)
+ *
+ * This function is implemented in terms of @c memcpy, and consequently it
+ * cannot be used to copy between overlapping memory regions.
  */
 inline std::size_t buffer_copy(const mutable_buffers_1& target,
     const mutable_buffers_1& source)
 {
   return buffer_copy(static_cast<const mutable_buffer&>(target),
       const_buffer(source));
@@ -1502,12 +1538,15 @@ inline std::size_t buffer_copy(const mutable_buffers_1& target,
  *
  * @note The number of bytes copied is the lesser of:
  *
  * @li @c buffer_size(target)
  *
  * @li @c buffer_size(source)
+ *
+ * This function is implemented in terms of @c memcpy, and consequently it
+ * cannot be used to copy between overlapping memory regions.
  */
 template <typename ConstBufferSequence>
 inline std::size_t buffer_copy(const mutable_buffers_1& target,
     const ConstBufferSequence& source)
 {
   return buffer_copy(static_cast<const mutable_buffer&>(target), source);
@@ -1525,12 +1564,15 @@ inline std::size_t buffer_copy(const mutable_buffers_1& target,
  *
  * @note The number of bytes copied is the lesser of:
  *
  * @li @c buffer_size(target)
  *
  * @li @c buffer_size(source)
+ *
+ * This function is implemented in terms of @c memcpy, and consequently it
+ * cannot be used to copy between overlapping memory regions.
  */
 template <typename MutableBufferSequence>
 std::size_t buffer_copy(const MutableBufferSequence& target,
     const const_buffer& source)
 {
   std::size_t total_bytes_copied = 0;
@@ -1562,12 +1604,15 @@ std::size_t buffer_copy(const MutableBufferSequence& target,
  *
  * @note The number of bytes copied is the lesser of:
  *
  * @li @c buffer_size(target)
  *
  * @li @c buffer_size(source)
+ *
+ * This function is implemented in terms of @c memcpy, and consequently it
+ * cannot be used to copy between overlapping memory regions.
  */
 template <typename MutableBufferSequence>
 inline std::size_t buffer_copy(const MutableBufferSequence& target,
     const const_buffers_1& source)
 {
   return buffer_copy(target, static_cast<const const_buffer&>(source));
@@ -1586,12 +1631,15 @@ inline std::size_t buffer_copy(const MutableBufferSequence& target,
  *
  * @note The number of bytes copied is the lesser of:
  *
  * @li @c buffer_size(target)
  *
  * @li @c buffer_size(source)
+ *
+ * This function is implemented in terms of @c memcpy, and consequently it
+ * cannot be used to copy between overlapping memory regions.
  */
 template <typename MutableBufferSequence>
 inline std::size_t buffer_copy(const MutableBufferSequence& target,
     const mutable_buffer& source)
 {
   return buffer_copy(target, const_buffer(source));
@@ -1610,12 +1658,15 @@ inline std::size_t buffer_copy(const MutableBufferSequence& target,
  *
  * @note The number of bytes copied is the lesser of:
  *
  * @li @c buffer_size(target)
  *
  * @li @c buffer_size(source)
+ *
+ * This function is implemented in terms of @c memcpy, and consequently it
+ * cannot be used to copy between overlapping memory regions.
  */
 template <typename MutableBufferSequence>
 inline std::size_t buffer_copy(const MutableBufferSequence& target,
     const mutable_buffers_1& source)
 {
   return buffer_copy(target, const_buffer(source));
@@ -1633,12 +1684,15 @@ inline std::size_t buffer_copy(const MutableBufferSequence& target,
  *
  * @note The number of bytes copied is the lesser of:
  *
  * @li @c buffer_size(target)
  *
  * @li @c buffer_size(source)
+ *
+ * This function is implemented in terms of @c memcpy, and consequently it
+ * cannot be used to copy between overlapping memory regions.
  */
 template <typename MutableBufferSequence, typename ConstBufferSequence>
 std::size_t buffer_copy(const MutableBufferSequence& target,
     const ConstBufferSequence& source)
 {
   std::size_t total_bytes_copied = 0;
@@ -1698,12 +1752,15 @@ std::size_t buffer_copy(const MutableBufferSequence& target,
  *
  * @li @c buffer_size(target)
  *
  * @li @c buffer_size(source)
  *
  * @li @c max_bytes_to_copy
+ *
+ * This function is implemented in terms of @c memcpy, and consequently it
+ * cannot be used to copy between overlapping memory regions.
  */
 inline std::size_t buffer_copy(const mutable_buffer& target,
     const const_buffer& source, std::size_t max_bytes_to_copy)
 {
   return buffer_copy(buffer(target, max_bytes_to_copy), source);
 }
@@ -1724,12 +1781,15 @@ inline std::size_t buffer_copy(const mutable_buffer& target,
  *
  * @li @c buffer_size(target)
  *
  * @li @c buffer_size(source)
  *
  * @li @c max_bytes_to_copy
+ *
+ * This function is implemented in terms of @c memcpy, and consequently it
+ * cannot be used to copy between overlapping memory regions.
  */
 inline std::size_t buffer_copy(const mutable_buffer& target,
     const const_buffers_1& source, std::size_t max_bytes_to_copy)
 {
   return buffer_copy(buffer(target, max_bytes_to_copy), source);
 }
@@ -1751,12 +1811,15 @@ inline std::size_t buffer_copy(const mutable_buffer& target,
  *
  * @li @c buffer_size(target)
  *
  * @li @c buffer_size(source)
  *
  * @li @c max_bytes_to_copy
+ *
+ * This function is implemented in terms of @c memcpy, and consequently it
+ * cannot be used to copy between overlapping memory regions.
  */
 inline std::size_t buffer_copy(const mutable_buffer& target,
     const mutable_buffer& source, std::size_t max_bytes_to_copy)
 {
   return buffer_copy(buffer(target, max_bytes_to_copy), source);
 }
@@ -1778,12 +1841,15 @@ inline std::size_t buffer_copy(const mutable_buffer& target,
  *
  * @li @c buffer_size(target)
  *
  * @li @c buffer_size(source)
  *
  * @li @c max_bytes_to_copy
+ *
+ * This function is implemented in terms of @c memcpy, and consequently it
+ * cannot be used to copy between overlapping memory regions.
  */
 inline std::size_t buffer_copy(const mutable_buffer& target,
     const mutable_buffers_1& source, std::size_t max_bytes_to_copy)
 {
   return buffer_copy(buffer(target, max_bytes_to_copy), source);
 }
@@ -1805,12 +1871,15 @@ inline std::size_t buffer_copy(const mutable_buffer& target,
  *
  * @li @c buffer_size(target)
  *
  * @li @c buffer_size(source)
  *
  * @li @c max_bytes_to_copy
+ *
+ * This function is implemented in terms of @c memcpy, and consequently it
+ * cannot be used to copy between overlapping memory regions.
  */
 template <typename ConstBufferSequence>
 inline std::size_t buffer_copy(const mutable_buffer& target,
     const ConstBufferSequence& source, std::size_t max_bytes_to_copy)
 {
   return buffer_copy(buffer(target, max_bytes_to_copy), source);
@@ -1832,12 +1901,15 @@ inline std::size_t buffer_copy(const mutable_buffer& target,
  *
  * @li @c buffer_size(target)
  *
  * @li @c buffer_size(source)
  *
  * @li @c max_bytes_to_copy
+ *
+ * This function is implemented in terms of @c memcpy, and consequently it
+ * cannot be used to copy between overlapping memory regions.
  */
 inline std::size_t buffer_copy(const mutable_buffers_1& target,
     const const_buffer& source, std::size_t max_bytes_to_copy)
 {
   return buffer_copy(buffer(target, max_bytes_to_copy), source);
 }
@@ -1858,12 +1930,15 @@ inline std::size_t buffer_copy(const mutable_buffers_1& target,
  *
  * @li @c buffer_size(target)
  *
  * @li @c buffer_size(source)
  *
  * @li @c max_bytes_to_copy
+ *
+ * This function is implemented in terms of @c memcpy, and consequently it
+ * cannot be used to copy between overlapping memory regions.
  */
 inline std::size_t buffer_copy(const mutable_buffers_1& target,
     const const_buffers_1& source, std::size_t max_bytes_to_copy)
 {
   return buffer_copy(buffer(target, max_bytes_to_copy), source);
 }
@@ -1885,12 +1960,15 @@ inline std::size_t buffer_copy(const mutable_buffers_1& target,
  *
  * @li @c buffer_size(target)
  *
  * @li @c buffer_size(source)
  *
  * @li @c max_bytes_to_copy
+ *
+ * This function is implemented in terms of @c memcpy, and consequently it
+ * cannot be used to copy between overlapping memory regions.
  */
 inline std::size_t buffer_copy(const mutable_buffers_1& target,
     const mutable_buffer& source, std::size_t max_bytes_to_copy)
 {
   return buffer_copy(buffer(target, max_bytes_to_copy), source);
 }
@@ -1912,12 +1990,15 @@ inline std::size_t buffer_copy(const mutable_buffers_1& target,
  *
  * @li @c buffer_size(target)
  *
  * @li @c buffer_size(source)
  *
  * @li @c max_bytes_to_copy
+ *
+ * This function is implemented in terms of @c memcpy, and consequently it
+ * cannot be used to copy between overlapping memory regions.
  */
 inline std::size_t buffer_copy(const mutable_buffers_1& target,
     const mutable_buffers_1& source, std::size_t max_bytes_to_copy)
 {
   return buffer_copy(buffer(target, max_bytes_to_copy), source);
 }
@@ -1939,12 +2020,15 @@ inline std::size_t buffer_copy(const mutable_buffers_1& target,
  *
  * @li @c buffer_size(target)
  *
  * @li @c buffer_size(source)
  *
  * @li @c max_bytes_to_copy
+ *
+ * This function is implemented in terms of @c memcpy, and consequently it
+ * cannot be used to copy between overlapping memory regions.
  */
 template <typename ConstBufferSequence>
 inline std::size_t buffer_copy(const mutable_buffers_1& target,
     const ConstBufferSequence& source, std::size_t max_bytes_to_copy)
 {
   return buffer_copy(buffer(target, max_bytes_to_copy), source);
@@ -1967,12 +2051,15 @@ inline std::size_t buffer_copy(const mutable_buffers_1& target,
  *
  * @li @c buffer_size(target)
  *
  * @li @c buffer_size(source)
  *
  * @li @c max_bytes_to_copy
+ *
+ * This function is implemented in terms of @c memcpy, and consequently it
+ * cannot be used to copy between overlapping memory regions.
  */
 template <typename MutableBufferSequence>
 inline std::size_t buffer_copy(const MutableBufferSequence& target,
     const const_buffer& source, std::size_t max_bytes_to_copy)
 {
   return buffer_copy(target, buffer(source, max_bytes_to_copy));
@@ -1995,12 +2082,15 @@ inline std::size_t buffer_copy(const MutableBufferSequence& target,
  *
  * @li @c buffer_size(target)
  *
  * @li @c buffer_size(source)
  *
  * @li @c max_bytes_to_copy
+ *
+ * This function is implemented in terms of @c memcpy, and consequently it
+ * cannot be used to copy between overlapping memory regions.
  */
 template <typename MutableBufferSequence>
 inline std::size_t buffer_copy(const MutableBufferSequence& target,
     const const_buffers_1& source, std::size_t max_bytes_to_copy)
 {
   return buffer_copy(target, buffer(source, max_bytes_to_copy));
@@ -2024,12 +2114,15 @@ inline std::size_t buffer_copy(const MutableBufferSequence& target,
  *
  * @li @c buffer_size(target)
  *
  * @li @c buffer_size(source)
  *
  * @li @c max_bytes_to_copy
+ *
+ * This function is implemented in terms of @c memcpy, and consequently it
+ * cannot be used to copy between overlapping memory regions.
  */
 template <typename MutableBufferSequence>
 inline std::size_t buffer_copy(const MutableBufferSequence& target,
     const mutable_buffer& source, std::size_t max_bytes_to_copy)
 {
   return buffer_copy(target, buffer(source, max_bytes_to_copy));
@@ -2053,12 +2146,15 @@ inline std::size_t buffer_copy(const MutableBufferSequence& target,
  *
  * @li @c buffer_size(target)
  *
  * @li @c buffer_size(source)
  *
  * @li @c max_bytes_to_copy
+ *
+ * This function is implemented in terms of @c memcpy, and consequently it
+ * cannot be used to copy between overlapping memory regions.
  */
 template <typename MutableBufferSequence>
 inline std::size_t buffer_copy(const MutableBufferSequence& target,
     const mutable_buffers_1& source, std::size_t max_bytes_to_copy)
 {
   return buffer_copy(target, buffer(source, max_bytes_to_copy));
@@ -2081,12 +2177,15 @@ inline std::size_t buffer_copy(const MutableBufferSequence& target,
  *
  * @li @c buffer_size(target)
  *
  * @li @c buffer_size(source)
  *
  * @li @c max_bytes_to_copy
+ *
+ * This function is implemented in terms of @c memcpy, and consequently it
+ * cannot be used to copy between overlapping memory regions.
  */
 template <typename MutableBufferSequence, typename ConstBufferSequence>
 std::size_t buffer_copy(const MutableBufferSequence& target,
     const ConstBufferSequence& source, std::size_t max_bytes_to_copy)
 {
   std::size_t total_bytes_copied = 0;
diff --git a/3rdParty/Boost/src/boost/asio/buffered_read_stream.hpp b/3rdParty/Boost/src/boost/asio/buffered_read_stream.hpp
index 3072580..91493e3 100644
--- a/3rdParty/Boost/src/boost/asio/buffered_read_stream.hpp
+++ b/3rdParty/Boost/src/boost/asio/buffered_read_stream.hpp
@@ -1,11 +1,11 @@
 //
 // buffered_read_stream.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)
 //
 
 #ifndef BOOST_ASIO_BUFFERED_READ_STREAM_HPP
@@ -14,19 +14,20 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 #include <cstddef>
-#include <boost/type_traits/remove_reference.hpp>
+#include <boost/asio/async_result.hpp>
 #include <boost/asio/buffered_read_stream_fwd.hpp>
 #include <boost/asio/buffer.hpp>
 #include <boost/asio/detail/bind_handler.hpp>
 #include <boost/asio/detail/buffer_resize_guard.hpp>
 #include <boost/asio/detail/buffered_stream_storage.hpp>
 #include <boost/asio/detail/noncopyable.hpp>
+#include <boost/asio/detail/type_traits.hpp>
 #include <boost/asio/error.hpp>
 #include <boost/asio/io_service.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
@@ -39,30 +40,30 @@ namespace asio {
  *
  * @par Thread Safety
  * @e Distinct @e objects: Safe.@n
  * @e Shared @e objects: Unsafe.
  *
  * @par Concepts:
- * AsyncReadStream, AsyncWriteStream, Stream, Sync_Read_Stream, SyncWriteStream.
+ * AsyncReadStream, AsyncWriteStream, Stream, SyncReadStream, SyncWriteStream.
  */
 template <typename Stream>
 class buffered_read_stream
   : private noncopyable
 {
 public:
   /// The type of the next layer.
-  typedef typename boost::remove_reference<Stream>::type next_layer_type;
+  typedef typename remove_reference<Stream>::type next_layer_type;
 
   /// The type of the lowest layer.
   typedef typename next_layer_type::lowest_layer_type lowest_layer_type;
 
 #if defined(GENERATING_DOCUMENTATION)
   /// The default buffer size.
   static const std::size_t default_buffer_size = implementation_defined;
 #else
-  BOOST_STATIC_CONSTANT(std::size_t, default_buffer_size = 1024);
+  BOOST_ASIO_STATIC_CONSTANT(std::size_t, default_buffer_size = 1024);
 #endif
 
   /// Construct, passing the specified argument to initialise the next layer.
   template <typename Arg>
   explicit buffered_read_stream(Arg& a)
     : next_layer_(a),
@@ -131,205 +132,71 @@ public:
     return next_layer_.write_some(buffers, ec);
   }
 
   /// Start an asynchronous write. The data being written must be valid for the
   /// lifetime of the asynchronous operation.
   template <typename ConstBufferSequence, typename WriteHandler>
-  void async_write_some(const ConstBufferSequence& buffers,
-      WriteHandler handler)
+  BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,
+      void (boost::system::error_code, std::size_t))
+  async_write_some(const ConstBufferSequence& buffers,
+      BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
   {
-    next_layer_.async_write_some(buffers, handler);
+    detail::async_result_init<
+      WriteHandler, void (boost::system::error_code, std::size_t)> init(
+        BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
+
+    next_layer_.async_write_some(buffers,
+        BOOST_ASIO_MOVE_CAST(BOOST_ASIO_HANDLER_TYPE(WriteHandler,
+            void (boost::system::error_code, std::size_t)))(init.handler));
+
+    return init.result.get();
   }
 
   /// Fill the buffer with some data. Returns the number of bytes placed in the
   /// buffer as a result of the operation. Throws an exception on failure.
-  std::size_t 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;
-  }
+  std::size_t fill();
 
   /// Fill the buffer with some data. Returns the number of bytes placed in the
   /// buffer as a result of the operation, or 0 if an error occurred.
-  std::size_t 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;
-  }
-
-  template <typename ReadHandler>
-  class fill_handler
-  {
-  public:
-    fill_handler(boost::asio::io_service& io_service,
-        detail::buffered_stream_storage& storage,
-        std::size_t previous_size, ReadHandler handler)
-      : io_service_(io_service),
-        storage_(storage),
-        previous_size_(previous_size),
-        handler_(handler)
-    {
-    }
-
-    void operator()(const boost::system::error_code& ec,
-        std::size_t bytes_transferred)
-    {
-      storage_.resize(previous_size_ + bytes_transferred);
-      io_service_.dispatch(detail::bind_handler(
-            handler_, ec, bytes_transferred));
-    }
-
-  private:
-    boost::asio::io_service& io_service_;
-    detail::buffered_stream_storage& storage_;
-    std::size_t previous_size_;
-    ReadHandler handler_;
-  };
+  std::size_t fill(boost::system::error_code& ec);
 
   /// Start an asynchronous fill.
   template <typename ReadHandler>
-  void async_fill(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),
-        fill_handler<ReadHandler>(get_io_service(),
-          storage_, previous_size, handler));
-  }
+  BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+      void (boost::system::error_code, std::size_t))
+  async_fill(BOOST_ASIO_MOVE_ARG(ReadHandler) handler);
 
   /// Read some data from the stream. Returns the number of bytes read. Throws
   /// an exception on failure.
   template <typename MutableBufferSequence>
-  std::size_t read_some(const MutableBufferSequence& buffers)
-  {
-    if (boost::asio::buffer_size(buffers) == 0)
-      return 0;
-
-    if (storage_.empty())
-      fill();
-
-    return copy(buffers);
-  }
+  std::size_t read_some(const MutableBufferSequence& buffers);
 
   /// Read some data from the stream. Returns the number of bytes read or 0 if
   /// an error occurred.
   template <typename MutableBufferSequence>
   std::size_t 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() && !fill(ec))
-      return 0;
-
-    return copy(buffers);
-  }
-
-  template <typename MutableBufferSequence, typename ReadHandler>
-  class read_some_handler
-  {
-  public:
-    read_some_handler(boost::asio::io_service& io_service,
-        detail::buffered_stream_storage& storage,
-        const MutableBufferSequence& buffers, ReadHandler handler)
-      : io_service_(io_service),
-        storage_(storage),
-        buffers_(buffers),
-        handler_(handler)
-    {
-    }
-
-    void operator()(const boost::system::error_code& ec, std::size_t)
-    {
-      if (ec || storage_.empty())
-      {
-        std::size_t length = 0;
-        io_service_.dispatch(detail::bind_handler(handler_, ec, length));
-      }
-      else
-      {
-        std::size_t bytes_copied = boost::asio::buffer_copy(
-            buffers_, storage_.data(), storage_.size());
-        storage_.consume(bytes_copied);
-        io_service_.dispatch(detail::bind_handler(handler_, ec, bytes_copied));
-      }
-    }
-
-  private:
-    boost::asio::io_service& io_service_;
-    detail::buffered_stream_storage& storage_;
-    MutableBufferSequence buffers_;
-    ReadHandler handler_;
-  };
+      boost::system::error_code& ec);
 
   /// Start an asynchronous read. The buffer into which the data will be read
   /// must be valid for the lifetime of the asynchronous operation.
   template <typename MutableBufferSequence, typename ReadHandler>
-  void async_read_some(const MutableBufferSequence& buffers,
-      ReadHandler handler)
-  {
-    if (boost::asio::buffer_size(buffers) == 0)
-    {
-      get_io_service().post(detail::bind_handler(
-            handler, boost::system::error_code(), 0));
-    }
-    else if (storage_.empty())
-    {
-      async_fill(read_some_handler<MutableBufferSequence, ReadHandler>(
-            get_io_service(), storage_, buffers, handler));
-    }
-    else
-    {
-      std::size_t length = copy(buffers);
-      get_io_service().post(detail::bind_handler(
-            handler, boost::system::error_code(), length));
-    }
-  }
+  BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+      void (boost::system::error_code, std::size_t))
+  async_read_some(const MutableBufferSequence& buffers,
+      BOOST_ASIO_MOVE_ARG(ReadHandler) handler);
 
   /// Peek at the incoming data on the stream. Returns the number of bytes read.
   /// Throws an exception on failure.
   template <typename MutableBufferSequence>
-  std::size_t peek(const MutableBufferSequence& buffers)
-  {
-    if (storage_.empty())
-      fill();
-    return peek_copy(buffers);
-  }
+  std::size_t peek(const MutableBufferSequence& buffers);
 
   /// Peek at the incoming data on the stream. Returns the number of bytes read,
   /// or 0 if an error occurred.
   template <typename MutableBufferSequence>
   std::size_t peek(const MutableBufferSequence& buffers,
-      boost::system::error_code& ec)
-  {
-    ec = boost::system::error_code();
-    if (storage_.empty() && !fill(ec))
-      return 0;
-    return peek_copy(buffers);
-  }
+      boost::system::error_code& ec);
 
   /// Determine the amount of data that may be read without blocking.
   std::size_t in_avail()
   {
     return storage_.size();
   }
@@ -371,7 +238,9 @@ private:
 
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
+#include <boost/asio/impl/buffered_read_stream.hpp>
+
 #endif // BOOST_ASIO_BUFFERED_READ_STREAM_HPP
diff --git a/3rdParty/Boost/src/boost/asio/buffered_read_stream_fwd.hpp b/3rdParty/Boost/src/boost/asio/buffered_read_stream_fwd.hpp
index 5c8c295..0f8a59e 100644
--- a/3rdParty/Boost/src/boost/asio/buffered_read_stream_fwd.hpp
+++ b/3rdParty/Boost/src/boost/asio/buffered_read_stream_fwd.hpp
@@ -1,11 +1,11 @@
 //
 // buffered_read_stream_fwd.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)
 //
 
 #ifndef BOOST_ASIO_BUFFERED_READ_STREAM_FWD_HPP
diff --git a/3rdParty/Boost/src/boost/asio/buffered_stream.hpp b/3rdParty/Boost/src/boost/asio/buffered_stream.hpp
index 632e5ce..b9ca771 100644
--- a/3rdParty/Boost/src/boost/asio/buffered_stream.hpp
+++ b/3rdParty/Boost/src/boost/asio/buffered_stream.hpp
@@ -1,11 +1,11 @@
 //
 // buffered_stream.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)
 //
 
 #ifndef BOOST_ASIO_BUFFERED_STREAM_HPP
@@ -14,12 +14,13 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 #include <cstddef>
+#include <boost/asio/async_result.hpp>
 #include <boost/asio/buffered_read_stream.hpp>
 #include <boost/asio/buffered_write_stream.hpp>
 #include <boost/asio/buffered_stream_fwd.hpp>
 #include <boost/asio/detail/noncopyable.hpp>
 #include <boost/asio/error.hpp>
 #include <boost/asio/io_service.hpp>
@@ -44,13 +45,13 @@ namespace asio {
 template <typename Stream>
 class buffered_stream
   : private noncopyable
 {
 public:
   /// The type of the next layer.
-  typedef typename boost::remove_reference<Stream>::type next_layer_type;
+  typedef typename remove_reference<Stream>::type next_layer_type;
 
   /// The type of the lowest layer.
   typedef typename next_layer_type::lowest_layer_type lowest_layer_type;
 
   /// Construct, passing the specified argument to initialise the next layer.
   template <typename Arg>
@@ -120,15 +121,18 @@ public:
   {
     return stream_impl_.next_layer().flush(ec);
   }
 
   /// Start an asynchronous flush.
   template <typename WriteHandler>
-  void async_flush(WriteHandler handler)
+  BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,
+      void (boost::system::error_code, std::size_t))
+  async_flush(BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
   {
-    return stream_impl_.next_layer().async_flush(handler);
+    return stream_impl_.next_layer().async_flush(
+        BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
   }
 
   /// Write the given data to the stream. Returns the number of bytes written.
   /// Throws an exception on failure.
   template <typename ConstBufferSequence>
   std::size_t write_some(const ConstBufferSequence& buffers)
@@ -145,16 +149,19 @@ public:
     return stream_impl_.write_some(buffers, ec);
   }
 
   /// Start an asynchronous write. The data being written must be valid for the
   /// lifetime of the asynchronous operation.
   template <typename ConstBufferSequence, typename WriteHandler>
-  void async_write_some(const ConstBufferSequence& buffers,
-      WriteHandler handler)
+  BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,
+      void (boost::system::error_code, std::size_t))
+  async_write_some(const ConstBufferSequence& buffers,
+      BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
   {
-    stream_impl_.async_write_some(buffers, handler);
+    return stream_impl_.async_write_some(buffers,
+        BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
   }
 
   /// Fill the buffer with some data. Returns the number of bytes placed in the
   /// buffer as a result of the operation. Throws an exception on failure.
   std::size_t fill()
   {
@@ -167,15 +174,17 @@ public:
   {
     return stream_impl_.fill(ec);
   }
 
   /// Start an asynchronous fill.
   template <typename ReadHandler>
-  void async_fill(ReadHandler handler)
+  BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+      void (boost::system::error_code, std::size_t))
+  async_fill(BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
   {
-    stream_impl_.async_fill(handler);
+    return stream_impl_.async_fill(BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
   }
 
   /// Read some data from the stream. Returns the number of bytes read. Throws
   /// an exception on failure.
   template <typename MutableBufferSequence>
   std::size_t read_some(const MutableBufferSequence& buffers)
@@ -192,16 +201,19 @@ public:
     return stream_impl_.read_some(buffers, ec);
   }
 
   /// Start an asynchronous read. The buffer into which the data will be read
   /// must be valid for the lifetime of the asynchronous operation.
   template <typename MutableBufferSequence, typename ReadHandler>
-  void async_read_some(const MutableBufferSequence& buffers,
-      ReadHandler handler)
+  BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+      void (boost::system::error_code, std::size_t))
+  async_read_some(const MutableBufferSequence& buffers,
+      BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
   {
-    stream_impl_.async_read_some(buffers, handler);
+    return stream_impl_.async_read_some(buffers,
+        BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
   }
 
   /// Peek at the incoming data on the stream. Returns the number of bytes read.
   /// Throws an exception on failure.
   template <typename MutableBufferSequence>
   std::size_t peek(const MutableBufferSequence& buffers)
diff --git a/3rdParty/Boost/src/boost/asio/buffered_stream_fwd.hpp b/3rdParty/Boost/src/boost/asio/buffered_stream_fwd.hpp
index 5241879..d51b3d1 100644
--- a/3rdParty/Boost/src/boost/asio/buffered_stream_fwd.hpp
+++ b/3rdParty/Boost/src/boost/asio/buffered_stream_fwd.hpp
@@ -1,11 +1,11 @@
 //
 // buffered_stream_fwd.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)
 //
 
 #ifndef BOOST_ASIO_BUFFERED_STREAM_FWD_HPP
diff --git a/3rdParty/Boost/src/boost/asio/buffered_write_stream.hpp b/3rdParty/Boost/src/boost/asio/buffered_write_stream.hpp
index 11cb872..d7bf68c 100644
--- a/3rdParty/Boost/src/boost/asio/buffered_write_stream.hpp
+++ b/3rdParty/Boost/src/boost/asio/buffered_write_stream.hpp
@@ -1,11 +1,11 @@
 //
 // buffered_write_stream.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)
 //
 
 #ifndef BOOST_ASIO_BUFFERED_WRITE_STREAM_HPP
@@ -14,19 +14,19 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 #include <cstddef>
-#include <boost/type_traits/remove_reference.hpp>
 #include <boost/asio/buffered_write_stream_fwd.hpp>
 #include <boost/asio/buffer.hpp>
 #include <boost/asio/completion_condition.hpp>
 #include <boost/asio/detail/bind_handler.hpp>
 #include <boost/asio/detail/buffered_stream_storage.hpp>
 #include <boost/asio/detail/noncopyable.hpp>
+#include <boost/asio/detail/type_traits.hpp>
 #include <boost/asio/error.hpp>
 #include <boost/asio/io_service.hpp>
 #include <boost/asio/write.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
@@ -48,22 +48,22 @@ namespace asio {
 template <typename Stream>
 class buffered_write_stream
   : private noncopyable
 {
 public:
   /// The type of the next layer.
-  typedef typename boost::remove_reference<Stream>::type next_layer_type;
+  typedef typename remove_reference<Stream>::type next_layer_type;
 
   /// The type of the lowest layer.
   typedef typename next_layer_type::lowest_layer_type lowest_layer_type;
 
 #if defined(GENERATING_DOCUMENTATION)
   /// The default buffer size.
   static const std::size_t default_buffer_size = implementation_defined;
 #else
-  BOOST_STATIC_CONSTANT(std::size_t, default_buffer_size = 1024);
+  BOOST_ASIO_STATIC_CONSTANT(std::size_t, default_buffer_size = 1024);
 #endif
 
   /// Construct, passing the specified argument to initialise the next layer.
   template <typename Arg>
   explicit buffered_write_stream(Arg& a)
     : next_layer_(a),
@@ -115,162 +115,43 @@ public:
     return next_layer_.close(ec);
   }
 
   /// Flush all data from the buffer to the next layer. Returns the number of
   /// bytes written to the next layer on the last write operation. Throws an
   /// exception on failure.
-  std::size_t flush()
-  {
-    std::size_t bytes_written = write(next_layer_,
-        buffer(storage_.data(), storage_.size()));
-    storage_.consume(bytes_written);
-    return bytes_written;
-  }
+  std::size_t flush();
 
   /// Flush all data from the buffer to the next layer. Returns the number of
   /// bytes written to the next layer on the last write operation, or 0 if an
   /// error occurred.
-  std::size_t 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;
-  }
-
-  template <typename WriteHandler>
-  class flush_handler
-  {
-  public:
-    flush_handler(boost::asio::io_service& io_service,
-        detail::buffered_stream_storage& storage, WriteHandler handler)
-      : io_service_(io_service),
-        storage_(storage),
-        handler_(handler)
-    {
-    }
-
-    void operator()(const boost::system::error_code& ec,
-        std::size_t bytes_written)
-    {
-      storage_.consume(bytes_written);
-      io_service_.dispatch(detail::bind_handler(handler_, ec, bytes_written));
-    }
-
-  private:
-    boost::asio::io_service& io_service_;
-    detail::buffered_stream_storage& storage_;
-    WriteHandler handler_;
-  };
+  std::size_t flush(boost::system::error_code& ec);
 
   /// Start an asynchronous flush.
   template <typename WriteHandler>
-  void async_flush(WriteHandler handler)
-  {
-    async_write(next_layer_, buffer(storage_.data(), storage_.size()),
-        flush_handler<WriteHandler>(get_io_service(), storage_, handler));
-  }
+  BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,
+      void (boost::system::error_code, std::size_t))
+  async_flush(BOOST_ASIO_MOVE_ARG(WriteHandler) handler);
 
   /// Write the given data to the stream. Returns the number of bytes written.
   /// Throws an exception on failure.
   template <typename ConstBufferSequence>
-  std::size_t write_some(const ConstBufferSequence& buffers)
-  {
-    if (boost::asio::buffer_size(buffers) == 0)
-      return 0;
-
-    if (storage_.size() == storage_.capacity())
-      flush();
-
-    return copy(buffers);
-  }
+  std::size_t write_some(const ConstBufferSequence& buffers);
 
   /// Write the given data to the stream. Returns the number of bytes written,
   /// or 0 if an error occurred and the error handler did not throw.
   template <typename ConstBufferSequence>
   std::size_t 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 copy(buffers);
-  }
-
-  template <typename ConstBufferSequence, typename WriteHandler>
-  class write_some_handler
-  {
-  public:
-    write_some_handler(boost::asio::io_service& io_service,
-        detail::buffered_stream_storage& storage,
-        const ConstBufferSequence& buffers, WriteHandler handler)
-      : io_service_(io_service),
-        storage_(storage),
-        buffers_(buffers),
-        handler_(handler)
-    {
-    }
-
-    void operator()(const boost::system::error_code& ec, std::size_t)
-    {
-      if (ec)
-      {
-        std::size_t length = 0;
-        io_service_.dispatch(detail::bind_handler(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);
-        std::size_t bytes_copied = boost::asio::buffer_copy(
-            storage_.data() + orig_size, buffers_, length);
-
-        io_service_.dispatch(detail::bind_handler(handler_, ec, bytes_copied));
-      }
-    }
-
-  private:
-    boost::asio::io_service& io_service_;
-    detail::buffered_stream_storage& storage_;
-    ConstBufferSequence buffers_;
-    WriteHandler handler_;
-  };
+      boost::system::error_code& ec);
 
   /// Start an asynchronous write. The data being written must be valid for the
   /// lifetime of the asynchronous operation.
   template <typename ConstBufferSequence, typename WriteHandler>
-  void async_write_some(const ConstBufferSequence& buffers,
-      WriteHandler handler)
-  {
-    if (boost::asio::buffer_size(buffers) == 0)
-    {
-      get_io_service().post(detail::bind_handler(
-            handler, boost::system::error_code(), 0));
-    }
-    else if (storage_.size() == storage_.capacity())
-    {
-      async_flush(write_some_handler<ConstBufferSequence, WriteHandler>(
-            get_io_service(), storage_, buffers, handler));
-    }
-    else
-    {
-      std::size_t bytes_copied = copy(buffers);
-      get_io_service().post(detail::bind_handler(
-            handler, boost::system::error_code(), bytes_copied));
-    }
-  }
+  BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,
+      void (boost::system::error_code, std::size_t))
+  async_write_some(const ConstBufferSequence& buffers,
+      BOOST_ASIO_MOVE_ARG(WriteHandler) handler);
 
   /// Read some data from the stream. Returns the number of bytes read. Throws
   /// an exception on failure.
   template <typename MutableBufferSequence>
   std::size_t read_some(const MutableBufferSequence& buffers)
   {
@@ -286,16 +167,26 @@ public:
     return next_layer_.read_some(buffers, ec);
   }
 
   /// Start an asynchronous read. The buffer into which the data will be read
   /// must be valid for the lifetime of the asynchronous operation.
   template <typename MutableBufferSequence, typename ReadHandler>
-  void async_read_some(const MutableBufferSequence& buffers,
-      ReadHandler handler)
+  BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+      void (boost::system::error_code, std::size_t))
+  async_read_some(const MutableBufferSequence& buffers,
+      BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
   {
-    next_layer_.async_read_some(buffers, handler);
+    detail::async_result_init<
+      ReadHandler, void (boost::system::error_code, std::size_t)> init(
+        BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
+
+    next_layer_.async_read_some(buffers,
+        BOOST_ASIO_MOVE_CAST(BOOST_ASIO_HANDLER_TYPE(ReadHandler,
+            void (boost::system::error_code, std::size_t)))(init.handler));
+
+    return init.result.get();
   }
 
   /// Peek at the incoming data on the stream. Returns the number of bytes read.
   /// Throws an exception on failure.
   template <typename MutableBufferSequence>
   std::size_t peek(const MutableBufferSequence& buffers)
@@ -325,22 +216,13 @@ public:
   }
 
 private:
   /// Copy data into the internal buffer from the specified source buffer.
   /// Returns the number of bytes copied.
   template <typename ConstBufferSequence>
-  std::size_t 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);
-  }
+  std::size_t copy(const ConstBufferSequence& buffers);
 
   /// The next layer.
   Stream next_layer_;
 
   // The data in the buffer.
   detail::buffered_stream_storage storage_;
@@ -348,7 +230,9 @@ private:
 
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
+#include <boost/asio/impl/buffered_write_stream.hpp>
+
 #endif // BOOST_ASIO_BUFFERED_WRITE_STREAM_HPP
diff --git a/3rdParty/Boost/src/boost/asio/buffered_write_stream_fwd.hpp b/3rdParty/Boost/src/boost/asio/buffered_write_stream_fwd.hpp
index 2da283f..3b83cdf 100644
--- a/3rdParty/Boost/src/boost/asio/buffered_write_stream_fwd.hpp
+++ b/3rdParty/Boost/src/boost/asio/buffered_write_stream_fwd.hpp
@@ -1,11 +1,11 @@
 //
 // buffered_write_stream_fwd.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)
 //
 
 #ifndef BOOST_ASIO_BUFFERED_WRITE_STREAM_FWD_HPP
diff --git a/3rdParty/Boost/src/boost/asio/buffers_iterator.hpp b/3rdParty/Boost/src/boost/asio/buffers_iterator.hpp
index c11e146..877f9f1 100644
--- a/3rdParty/Boost/src/boost/asio/buffers_iterator.hpp
+++ b/3rdParty/Boost/src/boost/asio/buffers_iterator.hpp
@@ -1,11 +1,11 @@
 //
 // buffers_iterator.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)
 //
 
 #ifndef BOOST_ASIO_BUFFERS_ITERATOR_HPP
@@ -15,17 +15,15 @@
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 #include <cstddef>
 #include <iterator>
-#include <boost/assert.hpp>
-#include <boost/detail/workaround.hpp>
-#include <boost/type_traits/is_convertible.hpp>
-#include <boost/type_traits/add_const.hpp>
 #include <boost/asio/buffer.hpp>
+#include <boost/asio/detail/assert.hpp>
+#include <boost/asio/detail/type_traits.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 
@@ -38,13 +36,13 @@ namespace detail
   struct buffers_iterator_types_helper<false>
   {
     typedef const_buffer buffer_type;
     template <typename ByteType>
     struct byte_type
     {
-      typedef typename boost::add_const<ByteType>::type type;
+      typedef typename add_const<ByteType>::type type;
     };
   };
 
   template <>
   struct buffers_iterator_types_helper<true>
   {
@@ -58,14 +56,15 @@ namespace detail
 
   template <typename BufferSequence, typename ByteType>
   struct buffers_iterator_types
   {
     enum
     {
-      is_mutable = boost::is_convertible<
-        typename BufferSequence::value_type, mutable_buffer>::value
+      is_mutable = is_convertible<
+          typename BufferSequence::value_type,
+          mutable_buffer>::value
     };
     typedef buffers_iterator_types_helper<is_mutable> helper;
     typedef typename helper::buffer_type buffer_type;
     typedef typename helper::template byte_type<ByteType>::type byte_type;
   };
 }
@@ -124,15 +123,15 @@ public:
       position_(0)
   {
   }
 
   /// Construct an iterator representing the beginning of the buffers' data.
   static buffers_iterator begin(const BufferSequence& buffers)
-#if BOOST_WORKAROUND(__GNUC__, == 4) && BOOST_WORKAROUND(__GNUC_MINOR__, == 3)
+#if defined(__GNUC__) && (__GNUC__ == 4) && (__GNUC_MINOR__ == 3)
     __attribute__ ((__noinline__))
-#endif
+#endif // defined(__GNUC__) && (__GNUC__ == 4) && (__GNUC_MINOR__ == 3)
   {
     buffers_iterator new_iter;
     new_iter.begin_ = buffers.begin();
     new_iter.current_ = buffers.begin();
     new_iter.end_ = buffers.end();
     while (new_iter.current_ != new_iter.end_)
@@ -144,15 +143,15 @@ public:
     }
     return new_iter;
   }
 
   /// Construct an iterator representing the end of the buffers' data.
   static buffers_iterator end(const BufferSequence& buffers)
-#if BOOST_WORKAROUND(__GNUC__, == 4) && BOOST_WORKAROUND(__GNUC_MINOR__, == 3)
+#if defined(__GNUC__) && (__GNUC__ == 4) && (__GNUC_MINOR__ == 3)
     __attribute__ ((__noinline__))
-#endif
+#endif // defined(__GNUC__) && (__GNUC__ == 4) && (__GNUC_MINOR__ == 3)
   {
     buffers_iterator new_iter;
     new_iter.begin_ = buffers.begin();
     new_iter.current_ = buffers.begin();
     new_iter.end_ = buffers.end();
     while (new_iter.current_ != new_iter.end_)
@@ -311,13 +310,13 @@ private:
     return position_ == other.position_;
   }
 
   // Increment the iterator.
   void increment()
   {
-    BOOST_ASSERT(current_ != end_ && "iterator out of bounds");
+    BOOST_ASIO_ASSERT(current_ != end_ && "iterator out of bounds");
     ++position_;
 
     // Check if the increment can be satisfied by the current buffer.
     ++current_buffer_position_;
     if (current_buffer_position_ != boost::asio::buffer_size(current_buffer_))
       return;
@@ -334,13 +333,13 @@ private:
     }
   }
 
   // Decrement the iterator.
   void decrement()
   {
-    BOOST_ASSERT(position_ > 0 && "iterator out of bounds");
+    BOOST_ASIO_ASSERT(position_ > 0 && "iterator out of bounds");
     --position_;
 
     // Check if the decrement can be satisfied by the current buffer.
     if (current_buffer_position_ != 0)
     {
       --current_buffer_position_;
@@ -366,13 +365,13 @@ private:
 
   // Advance the iterator by the specified distance.
   void advance(std::ptrdiff_t n)
   {
     if (n > 0)
     {
-      BOOST_ASSERT(current_ != end_ && "iterator out of bounds");
+      BOOST_ASIO_ASSERT(current_ != end_ && "iterator out of bounds");
       for (;;)
       {
         std::ptrdiff_t current_buffer_balance
           = boost::asio::buffer_size(current_buffer_)
           - current_buffer_position_;
 
@@ -389,25 +388,25 @@ private:
         position_ += current_buffer_balance;
 
         // Move to next buffer. If it is empty then it will be skipped on the
         // next iteration of this loop.
         if (++current_ == end_)
         {
-          BOOST_ASSERT(n == 0 && "iterator out of bounds");
+          BOOST_ASIO_ASSERT(n == 0 && "iterator out of bounds");
           current_buffer_ = buffer_type();
           current_buffer_position_ = 0;
           return;
         }
         current_buffer_ = *current_;
         current_buffer_position_ = 0;
       }
     }
     else if (n < 0)
     {
       std::size_t abs_n = -n;
-      BOOST_ASSERT(position_ >= abs_n && "iterator out of bounds");
+      BOOST_ASIO_ASSERT(position_ >= abs_n && "iterator out of bounds");
       for (;;)
       {
         // Check if the advance can be satisfied by the current buffer.
         if (current_buffer_position_ >= abs_n)
         {
           position_ -= abs_n;
@@ -419,13 +418,13 @@ private:
         abs_n -= current_buffer_position_;
         position_ -= current_buffer_position_;
 
         // Check if we've reached the beginning of the buffers.
         if (current_ == begin_)
         {
-          BOOST_ASSERT(abs_n == 0 && "iterator out of bounds");
+          BOOST_ASIO_ASSERT(abs_n == 0 && "iterator out of bounds");
           current_buffer_position_ = 0;
           return;
         }
 
         // Find the previous non-empty buffer.
         typename BufferSequence::const_iterator iter = current_;
diff --git a/3rdParty/Boost/src/boost/asio/completion_condition.hpp b/3rdParty/Boost/src/boost/asio/completion_condition.hpp
index 3d32c65..ed4f4fb 100644
--- a/3rdParty/Boost/src/boost/asio/completion_condition.hpp
+++ b/3rdParty/Boost/src/boost/asio/completion_condition.hpp
@@ -1,11 +1,11 @@
 //
 // completion_condition.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)
 //
 
 #ifndef BOOST_ASIO_COMPLETION_CONDITION_HPP
@@ -23,13 +23,13 @@
 namespace boost {
 namespace asio {
 
 namespace detail {
 
 // The default maximum number of bytes to transfer in a single operation.
-enum { default_max_transfer_size = 65536 };
+enum default_max_transfer_size_t { default_max_transfer_size = 65536 };
 
 // Adapt result of old-style completion conditions (which had a bool result
 // where true indicated that the operation was complete).
 inline std::size_t adapt_completion_condition_result(bool result)
 {
   return result ? 0 : default_max_transfer_size;
diff --git a/3rdParty/Boost/src/boost/asio/connect.hpp b/3rdParty/Boost/src/boost/asio/connect.hpp
index e54ea08..03c9fe7 100644
--- a/3rdParty/Boost/src/boost/asio/connect.hpp
+++ b/3rdParty/Boost/src/boost/asio/connect.hpp
@@ -1,11 +1,11 @@
 //
 // 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)
 //
 
 #ifndef BOOST_ASIO_CONNECT_HPP
@@ -13,12 +13,13 @@
 
 #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/async_result.hpp>
 #include <boost/asio/basic_socket.hpp>
 #include <boost/asio/error.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
@@ -513,13 +514,15 @@ Iterator connect(basic_socket<Protocol, SocketService>& s,
  * {
  *   // ...
  * } @endcode
  */
 template <typename Protocol, typename SocketService,
     typename Iterator, typename ComposedConnectHandler>
-void async_connect(basic_socket<Protocol, SocketService>& s,
+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);
 
 /// Asynchronously establishes a socket connection by trying each endpoint in a
 /// sequence.
 /**
  * This function attempts to connect a socket to one of a sequence of
@@ -582,13 +585,15 @@ void async_connect(basic_socket<Protocol, SocketService>& s,
  * {
  *   // ...
  * } @endcode
  */
 template <typename Protocol, typename SocketService,
     typename Iterator, typename ComposedConnectHandler>
-void async_connect(basic_socket<Protocol, SocketService>& s,
+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);
 
 /// Asynchronously establishes a socket connection by trying each endpoint in a
 /// sequence.
 /**
@@ -690,13 +695,15 @@ void async_connect(basic_socket<Protocol, SocketService>& s,
  *     std::cout << "Connected to: " << i->endpoint() << std::endl;
  *   }
  * } @endcode
  */
 template <typename Protocol, typename SocketService, typename Iterator,
     typename ConnectCondition, typename ComposedConnectHandler>
-void async_connect(basic_socket<Protocol, SocketService>& s, Iterator begin,
+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);
 
 /// Asynchronously establishes a socket connection by trying each endpoint in a
 /// sequence.
 /**
@@ -797,13 +804,15 @@ void async_connect(basic_socket<Protocol, SocketService>& s, Iterator begin,
  *     std::cout << "Connected to: " << i->endpoint() << std::endl;
  *   }
  * } @endcode
  */
 template <typename Protocol, typename SocketService, typename Iterator,
     typename ConnectCondition, typename ComposedConnectHandler>
-void async_connect(basic_socket<Protocol, SocketService>& s,
+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);
 
 /*@}*/
 
 } // namespace asio
diff --git a/3rdParty/Boost/src/boost/asio/coroutine.hpp b/3rdParty/Boost/src/boost/asio/coroutine.hpp
new file mode 100644
index 0000000..c01f66b
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/coroutine.hpp
@@ -0,0 +1,330 @@
+//
+// coroutine.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_COROUTINE_HPP
+#define BOOST_ASIO_COROUTINE_HPP
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+class coroutine_ref;
+
+} // namespace detail
+
+/// Provides support for implementing stackless coroutines.
+/**
+ * The @c coroutine class may be used to implement stackless coroutines. The
+ * class itself is used to store the current state of the coroutine.
+ *
+ * Coroutines are copy-constructible and assignable, and the space overhead is
+ * a single int. They can be used as a base class:
+ *
+ * @code class session : coroutine
+ * {
+ *   ...
+ * }; @endcode
+ *
+ * or as a data member:
+ *
+ * @code class session
+ * {
+ *   ...
+ *   coroutine coro_;
+ * }; @endcode
+ *
+ * or even bound in as a function argument using lambdas or @c bind(). The
+ * important thing is that as the application maintains a copy of the object
+ * for as long as the coroutine must be kept alive.
+ *
+ * @par Pseudo-keywords
+ *
+ * A coroutine is used in conjunction with certain "pseudo-keywords", which
+ * are implemented as macros. These macros are defined by a header file:
+ *
+ * @code #include <boost/asio/yield.hpp>@endcode
+ *
+ * and may conversely be undefined as follows:
+ *
+ * @code #include <boost/asio/unyield.hpp>@endcode
+ *
+ * <b>reenter</b>
+ *
+ * The @c reenter macro is used to define the body of a coroutine. It takes a
+ * single argument: a pointer or reference to a coroutine object. For example,
+ * if the base class is a coroutine object you may write:
+ *
+ * @code reenter (this)
+ * {
+ *   ... coroutine body ...
+ * } @endcode
+ *
+ * and if a data member or other variable you can write:
+ *
+ * @code reenter (coro_)
+ * {
+ *   ... coroutine body ...
+ * } @endcode
+ *
+ * When @c reenter is executed at runtime, control jumps to the location of the
+ * last @c yield or @c fork.
+ *
+ * The coroutine body may also be a single statement, such as:
+ *
+ * @code reenter (this) for (;;)
+ * {
+ *   ...
+ * } @endcode
+ *
+ * @b Limitation: The @c reenter macro is implemented using a switch. This
+ * means that you must take care when using local variables within the
+ * coroutine body. The local variable is not allowed in a position where
+ * reentering the coroutine could bypass the variable definition.
+ *
+ * <b>yield <em>statement</em></b>
+ *
+ * This form of the @c yield keyword is often used with asynchronous operations:
+ *
+ * @code yield socket_->async_read_some(buffer(*buffer_), *this); @endcode
+ *
+ * This divides into four logical steps:
+ *
+ * @li @c yield saves the current state of the coroutine.
+ * @li The statement initiates the asynchronous operation.
+ * @li The resume point is defined immediately following the statement.
+ * @li Control is transferred to the end of the coroutine body.
+ *
+ * When the asynchronous operation completes, the function object is invoked
+ * and @c reenter causes control to transfer to the resume point. It is
+ * important to remember to carry the coroutine state forward with the
+ * asynchronous operation. In the above snippet, the current class is a
+ * function object object with a coroutine object as base class or data member.
+ *
+ * The statement may also be a compound statement, and this permits us to
+ * define local variables with limited scope:
+ *
+ * @code yield
+ * {
+ *   mutable_buffers_1 b = buffer(*buffer_);
+ *   socket_->async_read_some(b, *this);
+ * } @endcode
+ *
+ * <b>yield return <em>expression</em> ;</b>
+ *
+ * This form of @c yield is often used in generators or coroutine-based parsers.
+ * For example, the function object:
+ *
+ * @code struct interleave : coroutine
+ * {
+ *   istream& is1;
+ *   istream& is2;
+ *   char operator()(char c)
+ *   {
+ *     reenter (this) for (;;)
+ *     {
+ *       yield return is1.get();
+ *       yield return is2.get();
+ *     }
+ *   }
+ * }; @endcode
+ *
+ * defines a trivial coroutine that interleaves the characters from two input
+ * streams.
+ *
+ * This type of @c yield divides into three logical steps:
+ *
+ * @li @c yield saves the current state of the coroutine.
+ * @li The resume point is defined immediately following the semicolon.
+ * @li The value of the expression is returned from the function.
+ *
+ * <b>yield ;</b>
+ *
+ * This form of @c yield is equivalent to the following steps:
+ *
+ * @li @c yield saves the current state of the coroutine.
+ * @li The resume point is defined immediately following the semicolon.
+ * @li Control is transferred to the end of the coroutine body.
+ *
+ * This form might be applied when coroutines are used for cooperative
+ * threading and scheduling is explicitly managed. For example:
+ *
+ * @code struct task : coroutine
+ * {
+ *   ...
+ *   void operator()()
+ *   {
+ *     reenter (this)
+ *     {
+ *       while (... not finished ...)
+ *       {
+ *         ... do something ...
+ *         yield;
+ *         ... do some more ...
+ *         yield;
+ *       }
+ *     }
+ *   }
+ *   ...
+ * };
+ * ...
+ * task t1, t2;
+ * for (;;)
+ * {
+ *   t1();
+ *   t2();
+ * } @endcode
+ *
+ * <b>yield break ;</b>
+ *
+ * The final form of @c yield is used to explicitly terminate the coroutine.
+ * This form is comprised of two steps:
+ *
+ * @li @c yield sets the coroutine state to indicate termination.
+ * @li Control is transferred to the end of the coroutine body.
+ *
+ * Once terminated, calls to is_complete() return true and the coroutine cannot
+ * be reentered.
+ *
+ * Note that a coroutine may also be implicitly terminated if the coroutine
+ * body is exited without a yield, e.g. by return, throw or by running to the
+ * end of the body.
+ *
+ * <b>fork <em>statement</em></b>
+ *
+ * The @c fork pseudo-keyword is used when "forking" a coroutine, i.e. splitting
+ * it into two (or more) copies. One use of @c fork is in a server, where a new
+ * coroutine is created to handle each client connection:
+ * 
+ * @code reenter (this)
+ * {
+ *   do
+ *   {
+ *     socket_.reset(new tcp::socket(io_service_));
+ *     yield acceptor->async_accept(*socket_, *this);
+ *     fork server(*this)();
+ *   } while (is_parent());
+ *   ... client-specific handling follows ...
+ * } @endcode
+ * 
+ * The logical steps involved in a @c fork are:
+ * 
+ * @li @c fork saves the current state of the coroutine.
+ * @li The statement creates a copy of the coroutine and either executes it
+ *     immediately or schedules it for later execution.
+ * @li The resume point is defined immediately following the semicolon.
+ * @li For the "parent", control immediately continues from the next line.
+ *
+ * The functions is_parent() and is_child() can be used to differentiate
+ * between parent and child. You would use these functions to alter subsequent
+ * control flow.
+ *
+ * Note that @c fork doesn't do the actual forking by itself. It is the
+ * application's responsibility to create a clone of the coroutine and call it.
+ * The clone can be called immediately, as above, or scheduled for delayed
+ * execution using something like io_service::post().
+ *
+ * @par Alternate macro names
+ *
+ * If preferred, an application can use macro names that follow a more typical
+ * naming convention, rather than the pseudo-keywords. These are:
+ *
+ * @li @c BOOST_ASIO_CORO_REENTER instead of @c reenter
+ * @li @c BOOST_ASIO_CORO_YIELD instead of @c yield
+ * @li @c BOOST_ASIO_CORO_FORK instead of @c fork
+ */
+class coroutine
+{
+public:
+  /// Constructs a coroutine in its initial state.
+  coroutine() : value_(0) {}
+
+  /// Returns true if the coroutine is the child of a fork.
+  bool is_child() const { return value_ < 0; }
+
+  /// Returns true if the coroutine is the parent of a fork.
+  bool is_parent() const { return !is_child(); }
+
+  /// Returns true if the coroutine has reached its terminal state.
+  bool is_complete() const { return value_ == -1; }
+
+private:
+  friend class detail::coroutine_ref;
+  int value_;
+};
+
+
+namespace detail {
+
+class coroutine_ref
+{
+public:
+  coroutine_ref(coroutine& c) : value_(c.value_), modified_(false) {}
+  coroutine_ref(coroutine* c) : value_(c->value_), modified_(false) {}
+  ~coroutine_ref() { if (!modified_) value_ = -1; }
+  operator int() const { return value_; }
+  int& operator=(int v) { modified_ = true; return value_ = v; }
+private:
+  void operator=(const coroutine_ref&);
+  int& value_;
+  bool modified_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#define BOOST_ASIO_CORO_REENTER(c) \
+  switch (::boost::asio::detail::coroutine_ref _coro_value = c) \
+    case -1: if (_coro_value) \
+    { \
+      goto terminate_coroutine; \
+      terminate_coroutine: \
+      _coro_value = -1; \
+      goto bail_out_of_coroutine; \
+      bail_out_of_coroutine: \
+      break; \
+    } \
+    else case 0:
+
+#define BOOST_ASIO_CORO_YIELD_IMPL(n) \
+  for (_coro_value = (n);;) \
+    if (_coro_value == 0) \
+    { \
+      case (n): ; \
+      break; \
+    } \
+    else \
+      switch (_coro_value ? 0 : 1) \
+        for (;;) \
+          case -1: if (_coro_value) \
+            goto terminate_coroutine; \
+          else for (;;) \
+            case 1: if (_coro_value) \
+              goto bail_out_of_coroutine; \
+            else case 0:
+
+#define BOOST_ASIO_CORO_FORK_IMPL(n) \
+  for (_coro_value = -(n);; _coro_value = (n)) \
+    if (_coro_value == (n)) \
+    { \
+      case -(n): ; \
+      break; \
+    } \
+    else
+
+#if defined(_MSC_VER)
+# define BOOST_ASIO_CORO_YIELD BOOST_ASIO_CORO_YIELD_IMPL(__COUNTER__ + 1)
+# define BOOST_ASIO_CORO_FORK BOOST_ASIO_CORO_FORK_IMPL(__COUNTER__ + 1)
+#else // defined(_MSC_VER)
+# define BOOST_ASIO_CORO_YIELD BOOST_ASIO_CORO_YIELD_IMPL(__LINE__)
+# define BOOST_ASIO_CORO_FORK BOOST_ASIO_CORO_FORK_IMPL(__LINE__)
+#endif // defined(_MSC_VER)
+
+#endif // BOOST_ASIO_COROUTINE_HPP
diff --git a/3rdParty/Boost/src/boost/asio/datagram_socket_service.hpp b/3rdParty/Boost/src/boost/asio/datagram_socket_service.hpp
index 6e60a4f..91c8aa1 100644
--- a/3rdParty/Boost/src/boost/asio/datagram_socket_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/datagram_socket_service.hpp
@@ -1,11 +1,11 @@
 //
 // datagram_socket_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)
 //
 
 #ifndef BOOST_ASIO_DATAGRAM_SOCKET_SERVICE_HPP
@@ -14,16 +14,20 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 #include <cstddef>
+#include <boost/asio/async_result.hpp>
+#include <boost/asio/detail/type_traits.hpp>
 #include <boost/asio/error.hpp>
 #include <boost/asio/io_service.hpp>
 
-#if defined(BOOST_ASIO_HAS_IOCP)
+#if defined(BOOST_ASIO_WINDOWS_RUNTIME)
+# include <boost/asio/detail/null_socket_service.hpp>
+#elif defined(BOOST_ASIO_HAS_IOCP)
 # include <boost/asio/detail/win_iocp_socket_service.hpp>
 #else
 # include <boost/asio/detail/reactive_socket_service.hpp>
 #endif
 
 #include <boost/asio/detail/push_options.hpp>
@@ -51,13 +55,15 @@ public:
 
   /// The endpoint type.
   typedef typename Protocol::endpoint endpoint_type;
 
 private:
   // The type of the platform-specific implementation.
-#if defined(BOOST_ASIO_HAS_IOCP)
+#if defined(BOOST_ASIO_WINDOWS_RUNTIME)
+  typedef detail::null_socket_service<Protocol> service_impl_type;
+#elif defined(BOOST_ASIO_HAS_IOCP)
   typedef detail::win_iocp_socket_service<Protocol> service_impl_type;
 #else
   typedef detail::reactive_socket_service<Protocol> service_impl_type;
 #endif
 
 public:
@@ -108,25 +114,38 @@ public:
   void move_assign(implementation_type& impl,
       datagram_socket_service& other_service,
       implementation_type& other_impl)
   {
     service_impl_.move_assign(impl, other_service.service_impl_, other_impl);
   }
+
+  /// Move-construct a new datagram socket implementation from another protocol
+  /// type.
+  template <typename Protocol1>
+  void converting_move_construct(implementation_type& impl,
+      typename datagram_socket_service<
+        Protocol1>::implementation_type& other_impl,
+      typename enable_if<is_convertible<
+        Protocol1, Protocol>::value>::type* = 0)
+  {
+    service_impl_.template converting_move_construct<Protocol1>(
+        impl, other_impl);
+  }
 #endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
 
   /// Destroy a datagram socket implementation.
   void destroy(implementation_type& impl)
   {
     service_impl_.destroy(impl);
   }
 
   // Open a new datagram socket implementation.
   boost::system::error_code open(implementation_type& impl,
       const protocol_type& protocol, boost::system::error_code& ec)
   {
-    if (protocol.type() == SOCK_DGRAM)
+    if (protocol.type() == BOOST_ASIO_OS_DEF(SOCK_DGRAM))
       service_impl_.open(impl, protocol, ec);
     else
       ec = boost::asio::error::invalid_argument;
     return ec;
   }
 
@@ -197,18 +216,25 @@ public:
   {
     return service_impl_.connect(impl, peer_endpoint, ec);
   }
 
   /// Start an asynchronous connect.
   template <typename ConnectHandler>
-  void async_connect(implementation_type& impl,
+  BOOST_ASIO_INITFN_RESULT_TYPE(ConnectHandler,
+      void (boost::system::error_code))
+  async_connect(implementation_type& impl,
       const endpoint_type& peer_endpoint,
       BOOST_ASIO_MOVE_ARG(ConnectHandler) handler)
   {
-    service_impl_.async_connect(impl, peer_endpoint,
+    detail::async_result_init<
+      ConnectHandler, void (boost::system::error_code)> init(
         BOOST_ASIO_MOVE_CAST(ConnectHandler)(handler));
+
+    service_impl_.async_connect(impl, peer_endpoint, init.handler);
+
+    return init.result.get();
   }
 
   /// Set a socket option.
   template <typename SettableSocketOption>
   boost::system::error_code set_option(implementation_type& impl,
       const SettableSocketOption& option, boost::system::error_code& ec)
@@ -287,18 +313,25 @@ public:
   {
     return service_impl_.send(impl, buffers, flags, ec);
   }
 
   /// Start an asynchronous send.
   template <typename ConstBufferSequence, typename WriteHandler>
-  void async_send(implementation_type& impl, const ConstBufferSequence& buffers,
+  BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,
+      void (boost::system::error_code, std::size_t))
+  async_send(implementation_type& impl, const ConstBufferSequence& buffers,
       socket_base::message_flags flags,
       BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
   {
-    service_impl_.async_send(impl, buffers, flags,
+    detail::async_result_init<
+      WriteHandler, void (boost::system::error_code, std::size_t)> init(
         BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
+
+    service_impl_.async_send(impl, buffers, flags, init.handler);
+
+    return init.result.get();
   }
 
   /// Send a datagram to the specified endpoint.
   template <typename ConstBufferSequence>
   std::size_t send_to(implementation_type& impl,
       const ConstBufferSequence& buffers, const endpoint_type& destination,
@@ -306,19 +339,27 @@ public:
   {
     return service_impl_.send_to(impl, buffers, destination, flags, ec);
   }
 
   /// Start an asynchronous send.
   template <typename ConstBufferSequence, typename WriteHandler>
-  void async_send_to(implementation_type& impl,
+  BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,
+      void (boost::system::error_code, std::size_t))
+  async_send_to(implementation_type& impl,
       const ConstBufferSequence& buffers, const endpoint_type& destination,
       socket_base::message_flags flags,
       BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
   {
-    service_impl_.async_send_to(impl, buffers, destination, flags,
+    detail::async_result_init<
+      WriteHandler, void (boost::system::error_code, std::size_t)> init(
         BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
+
+    service_impl_.async_send_to(impl, buffers,
+        destination, flags, init.handler);
+
+    return init.result.get();
   }
 
   /// Receive some data from the peer.
   template <typename MutableBufferSequence>
   std::size_t receive(implementation_type& impl,
       const MutableBufferSequence& buffers,
@@ -326,19 +367,26 @@ public:
   {
     return service_impl_.receive(impl, buffers, flags, ec);
   }
 
   /// Start an asynchronous receive.
   template <typename MutableBufferSequence, typename ReadHandler>
-  void async_receive(implementation_type& impl,
+  BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+      void (boost::system::error_code, std::size_t))
+  async_receive(implementation_type& impl,
       const MutableBufferSequence& buffers,
       socket_base::message_flags flags,
       BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
   {
-    service_impl_.async_receive(impl, buffers, flags,
+    detail::async_result_init<
+      ReadHandler, void (boost::system::error_code, std::size_t)> init(
         BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
+
+    service_impl_.async_receive(impl, buffers, flags, init.handler);
+
+    return init.result.get();
   }
 
   /// Receive a datagram with the endpoint of the sender.
   template <typename MutableBufferSequence>
   std::size_t receive_from(implementation_type& impl,
       const MutableBufferSequence& buffers, endpoint_type& sender_endpoint,
@@ -347,19 +395,27 @@ public:
     return service_impl_.receive_from(impl, buffers, sender_endpoint, flags,
         ec);
   }
 
   /// Start an asynchronous receive that will get the endpoint of the sender.
   template <typename MutableBufferSequence, typename ReadHandler>
-  void async_receive_from(implementation_type& impl,
+  BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+      void (boost::system::error_code, std::size_t))
+  async_receive_from(implementation_type& impl,
       const MutableBufferSequence& buffers, endpoint_type& sender_endpoint,
       socket_base::message_flags flags,
       BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
   {
-    service_impl_.async_receive_from(impl, buffers, sender_endpoint, flags,
+    detail::async_result_init<
+      ReadHandler, void (boost::system::error_code, std::size_t)> init(
         BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
+
+    service_impl_.async_receive_from(impl, buffers,
+        sender_endpoint, flags, init.handler);
+
+    return init.result.get();
   }
 
 private:
   // Destroy all user-defined handler objects owned by the service.
   void shutdown_service()
   {
diff --git a/3rdParty/Boost/src/boost/asio/deadline_timer.hpp b/3rdParty/Boost/src/boost/asio/deadline_timer.hpp
index 82e65a7..b78d3ce 100644
--- a/3rdParty/Boost/src/boost/asio/deadline_timer.hpp
+++ b/3rdParty/Boost/src/boost/asio/deadline_timer.hpp
@@ -1,11 +1,11 @@
 //
 // deadline_timer.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)
 //
 
 #ifndef BOOST_ASIO_DEADLINE_TIMER_HPP
@@ -13,12 +13,16 @@
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HAS_BOOST_DATE_TIME) \
+  || defined(GENERATING_DOCUMENTATION)
+
 #include <boost/asio/detail/socket_types.hpp> // Must come before posix_time.
 #include <boost/asio/basic_deadline_timer.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 #include <boost/date_time/posix_time/posix_time_types.hpp>
 #include <boost/asio/detail/pop_options.hpp>
@@ -29,7 +33,10 @@ namespace asio {
 /// Typedef for the typical usage of timer. Uses a UTC clock.
 typedef basic_deadline_timer<boost::posix_time::ptime> deadline_timer;
 
 } // namespace asio
 } // namespace boost
 
+#endif // defined(BOOST_ASIO_HAS_BOOST_DATE_TIME)
+       // || defined(GENERATING_DOCUMENTATION)
+
 #endif // BOOST_ASIO_DEADLINE_TIMER_HPP
diff --git a/3rdParty/Boost/src/boost/asio/deadline_timer_service.hpp b/3rdParty/Boost/src/boost/asio/deadline_timer_service.hpp
index b538307..ba7f00a 100644
--- a/3rdParty/Boost/src/boost/asio/deadline_timer_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/deadline_timer_service.hpp
@@ -1,11 +1,11 @@
 //
 // deadline_timer_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)
 //
 
 #ifndef BOOST_ASIO_DEADLINE_TIMER_SERVICE_HPP
@@ -13,13 +13,18 @@
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HAS_BOOST_DATE_TIME) \
+  || defined(GENERATING_DOCUMENTATION)
+
 #include <cstddef>
+#include <boost/asio/async_result.hpp>
 #include <boost/asio/detail/deadline_timer_service.hpp>
 #include <boost/asio/io_service.hpp>
 #include <boost/asio/time_traits.hpp>
 #include <boost/asio/detail/timer_queue_ptime.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
@@ -129,16 +134,24 @@ public:
   {
     service_impl_.wait(impl, ec);
   }
 
   // Start an asynchronous wait on the timer.
   template <typename WaitHandler>
-  void async_wait(implementation_type& impl,
+  BOOST_ASIO_INITFN_RESULT_TYPE(WaitHandler,
+      void (boost::system::error_code))
+  async_wait(implementation_type& impl,
       BOOST_ASIO_MOVE_ARG(WaitHandler) handler)
   {
-    service_impl_.async_wait(impl, BOOST_ASIO_MOVE_CAST(WaitHandler)(handler));
+    detail::async_result_init<
+      WaitHandler, void (boost::system::error_code)> init(
+        BOOST_ASIO_MOVE_CAST(WaitHandler)(handler));
+
+    service_impl_.async_wait(impl, init.handler);
+
+    return init.result.get();
   }
 
 private:
   // Destroy all user-defined handler objects owned by the service.
   void shutdown_service()
   {
@@ -151,7 +164,10 @@ private:
 
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
+#endif // defined(BOOST_ASIO_HAS_BOOST_DATE_TIME)
+       // || defined(GENERATING_DOCUMENTATION)
+
 #endif // BOOST_ASIO_DEADLINE_TIMER_SERVICE_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/addressof.hpp b/3rdParty/Boost/src/boost/asio/detail/addressof.hpp
new file mode 100644
index 0000000..7b47331
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/detail/addressof.hpp
@@ -0,0 +1,40 @@
+//
+// detail/addressof.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_DETAIL_ADDRESSOF_HPP
+#define BOOST_ASIO_DETAIL_ADDRESSOF_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HAS_STD_ADDRESSOF)
+# include <memory>
+#else // defined(BOOST_ASIO_HAS_STD_ADDRESSOF)
+# include <boost/utility/addressof.hpp>
+#endif // defined(BOOST_ASIO_HAS_STD_ADDRESSOF)
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+#if defined(BOOST_ASIO_HAS_STD_ADDRESSOF)
+using std::addressof;
+#else // defined(BOOST_ASIO_HAS_STD_ADDRESSOF)
+using boost::addressof;
+#endif // defined(BOOST_ASIO_HAS_STD_ADDRESSOF)
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#endif // BOOST_ASIO_DETAIL_ADDRESSOF_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/array.hpp b/3rdParty/Boost/src/boost/asio/detail/array.hpp
index be141b1..8909e24 100644
--- a/3rdParty/Boost/src/boost/asio/detail/array.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/array.hpp
@@ -1,11 +1,11 @@
 //
 // detail/array.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_ARRAY_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/array_fwd.hpp b/3rdParty/Boost/src/boost/asio/detail/array_fwd.hpp
index f97ed0b..219f45c 100644
--- a/3rdParty/Boost/src/boost/asio/detail/array_fwd.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/array_fwd.hpp
@@ -1,11 +1,11 @@
 //
 // detail/array_fwd.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_ARRAY_FWD_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/assert.hpp b/3rdParty/Boost/src/boost/asio/detail/assert.hpp
new file mode 100644
index 0000000..b4498d1
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/detail/assert.hpp
@@ -0,0 +1,32 @@
+//
+// detail/assert.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_DETAIL_ASSERT_HPP
+#define BOOST_ASIO_DETAIL_ASSERT_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HAS_BOOST_ASSERT)
+# include <boost/assert.hpp>
+#else // defined(BOOST_ASIO_HAS_BOOST_ASSERT)
+# include <cassert>
+#endif // defined(BOOST_ASIO_HAS_BOOST_ASSERT)
+
+#if defined(BOOST_ASIO_HAS_BOOST_ASSERT)
+# define BOOST_ASIO_ASSERT(expr) BOOST_ASSERT(expr)
+#else // defined(BOOST_ASIO_HAS_BOOST_ASSERT)
+# define BOOST_ASIO_ASSERT(expr) assert(expr)
+#endif // defined(BOOST_ASIO_HAS_BOOST_ASSERT)
+
+#endif // BOOST_ASIO_DETAIL_ASSERT_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/atomic_count.hpp b/3rdParty/Boost/src/boost/asio/detail/atomic_count.hpp
index 5e0051a..c39e926 100644
--- a/3rdParty/Boost/src/boost/asio/detail/atomic_count.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/atomic_count.hpp
@@ -1,11 +1,11 @@
 //
 // detail/atomic_count.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_ATOMIC_COUNT_HPP
@@ -14,25 +14,25 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
-#if !defined(BOOST_HAS_THREADS) || defined(BOOST_ASIO_DISABLE_THREADS)
+#if !defined(BOOST_ASIO_HAS_THREADS)
 // Nothing to include.
 #elif defined(BOOST_ASIO_HAS_STD_ATOMIC)
 # include <atomic>
 #else // defined(BOOST_ASIO_HAS_STD_ATOMIC)
 # include <boost/detail/atomic_count.hpp>
 #endif // defined(BOOST_ASIO_HAS_STD_ATOMIC)
 
 namespace boost {
 namespace asio {
 namespace detail {
 
-#if !defined(BOOST_HAS_THREADS) || defined(BOOST_ASIO_DISABLE_THREADS)
+#if !defined(BOOST_ASIO_HAS_THREADS)
 typedef long atomic_count;
 inline void increment(atomic_count& a, long b) { a += b; }
 #elif defined(BOOST_ASIO_HAS_STD_ATOMIC)
 typedef std::atomic<long> atomic_count;
 inline void increment(atomic_count& a, long b) { a += b; }
 #else // defined(BOOST_ASIO_HAS_STD_ATOMIC)
diff --git a/3rdParty/Boost/src/boost/asio/detail/base_from_completion_cond.hpp b/3rdParty/Boost/src/boost/asio/detail/base_from_completion_cond.hpp
index 635b9c1..07e24f0 100644
--- a/3rdParty/Boost/src/boost/asio/detail/base_from_completion_cond.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/base_from_completion_cond.hpp
@@ -1,11 +1,11 @@
 //
 // detail/base_from_completion_cond.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_BASE_FROM_COMPLETION_COND_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/bind_handler.hpp b/3rdParty/Boost/src/boost/asio/detail/bind_handler.hpp
index 0bd7e53..e8f488d 100644
--- a/3rdParty/Boost/src/boost/asio/detail/bind_handler.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/bind_handler.hpp
@@ -1,11 +1,11 @@
 //
 // detail/bind_handler.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_BIND_HANDLER_HPP
@@ -14,12 +14,13 @@
 #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/handler_alloc_helpers.hpp>
+#include <boost/asio/detail/handler_cont_helpers.hpp>
 #include <boost/asio/detail/handler_invoke_helpers.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
@@ -69,12 +70,20 @@ inline void asio_handler_deallocate(void* pointer, std::size_t size,
     binder1<Handler, Arg1>* this_handler)
 {
   boost_asio_handler_alloc_helpers::deallocate(
       pointer, size, this_handler->handler_);
 }
 
+template <typename Handler, typename Arg1>
+inline bool asio_handler_is_continuation(
+    binder1<Handler, Arg1>* this_handler)
+{
+  return boost_asio_handler_cont_helpers::is_continuation(
+      this_handler->handler_);
+}
+
 template <typename Function, typename Handler, typename Arg1>
 inline void asio_handler_invoke(Function& function,
     binder1<Handler, Arg1>* this_handler)
 {
   boost_asio_handler_invoke_helpers::invoke(
       function, this_handler->handler_);
@@ -143,12 +152,20 @@ inline void asio_handler_deallocate(void* pointer, std::size_t size,
     binder2<Handler, Arg1, Arg2>* this_handler)
 {
   boost_asio_handler_alloc_helpers::deallocate(
       pointer, size, this_handler->handler_);
 }
 
+template <typename Handler, typename Arg1, typename Arg2>
+inline bool asio_handler_is_continuation(
+    binder2<Handler, Arg1, Arg2>* this_handler)
+{
+  return boost_asio_handler_cont_helpers::is_continuation(
+      this_handler->handler_);
+}
+
 template <typename Function, typename Handler, typename Arg1, typename Arg2>
 inline void asio_handler_invoke(Function& function,
     binder2<Handler, Arg1, Arg2>* this_handler)
 {
   boost_asio_handler_invoke_helpers::invoke(
       function, this_handler->handler_);
@@ -223,12 +240,20 @@ inline void asio_handler_deallocate(void* pointer, std::size_t size,
     binder3<Handler, Arg1, Arg2, Arg3>* this_handler)
 {
   boost_asio_handler_alloc_helpers::deallocate(
       pointer, size, this_handler->handler_);
 }
 
+template <typename Handler, typename Arg1, typename Arg2, typename Arg3>
+inline bool asio_handler_is_continuation(
+    binder3<Handler, Arg1, Arg2, Arg3>* this_handler)
+{
+  return boost_asio_handler_cont_helpers::is_continuation(
+      this_handler->handler_);
+}
+
 template <typename Function, typename Handler, typename Arg1, typename Arg2,
     typename Arg3>
 inline void asio_handler_invoke(Function& function,
     binder3<Handler, Arg1, Arg2, Arg3>* this_handler)
 {
   boost_asio_handler_invoke_helpers::invoke(
@@ -312,12 +337,21 @@ inline void asio_handler_deallocate(void* pointer, std::size_t size,
     binder4<Handler, Arg1, Arg2, Arg3, Arg4>* this_handler)
 {
   boost_asio_handler_alloc_helpers::deallocate(
       pointer, size, this_handler->handler_);
 }
 
+template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
+    typename Arg4>
+inline bool asio_handler_is_continuation(
+    binder4<Handler, Arg1, Arg2, Arg3, Arg4>* this_handler)
+{
+  return boost_asio_handler_cont_helpers::is_continuation(
+      this_handler->handler_);
+}
+
 template <typename Function, typename Handler, typename Arg1, typename Arg2,
     typename Arg3, typename Arg4>
 inline void asio_handler_invoke(Function& function,
     binder4<Handler, Arg1, Arg2, Arg3, Arg4>* this_handler)
 {
   boost_asio_handler_invoke_helpers::invoke(
@@ -408,12 +442,21 @@ inline void asio_handler_deallocate(void* pointer, std::size_t size,
     binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>* this_handler)
 {
   boost_asio_handler_alloc_helpers::deallocate(
       pointer, size, this_handler->handler_);
 }
 
+template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
+    typename Arg4, typename Arg5>
+inline bool asio_handler_is_continuation(
+    binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>* this_handler)
+{
+  return boost_asio_handler_cont_helpers::is_continuation(
+      this_handler->handler_);
+}
+
 template <typename Function, typename Handler, typename Arg1, typename Arg2,
     typename Arg3, typename Arg4, typename Arg5>
 inline void asio_handler_invoke(Function& function,
     binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>* this_handler)
 {
   boost_asio_handler_invoke_helpers::invoke(
diff --git a/3rdParty/Boost/src/boost/asio/detail/buffer_resize_guard.hpp b/3rdParty/Boost/src/boost/asio/detail/buffer_resize_guard.hpp
index ea78330..56304e5 100644
--- a/3rdParty/Boost/src/boost/asio/detail/buffer_resize_guard.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/buffer_resize_guard.hpp
@@ -1,11 +1,11 @@
 //
 // detail/buffer_resize_guard.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_BUFFER_RESIZE_GUARD_HPP
@@ -13,13 +13,13 @@
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
-#include <boost/limits.hpp>
+#include <boost/asio/detail/limits.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
@@ -36,24 +36,22 @@ public:
   {
   }
 
   // Destructor rolls back the buffer resize unless commit was called.
   ~buffer_resize_guard()
   {
-    if (old_size_
-        != std::numeric_limits<size_t>::max BOOST_PREVENT_MACRO_SUBSTITUTION())
+    if (old_size_ != (std::numeric_limits<size_t>::max)())
     {
       buffer_.resize(old_size_);
     }
   }
 
   // Commit the resize transaction.
   void commit()
   {
-    old_size_
-      = std::numeric_limits<size_t>::max BOOST_PREVENT_MACRO_SUBSTITUTION();
+    old_size_ = (std::numeric_limits<size_t>::max)();
   }
 
 private:
   // The buffer being managed.
   Buffer& buffer_;
 
diff --git a/3rdParty/Boost/src/boost/asio/detail/buffer_sequence_adapter.hpp b/3rdParty/Boost/src/boost/asio/detail/buffer_sequence_adapter.hpp
index 562aa55..da81cbe 100644
--- a/3rdParty/Boost/src/boost/asio/detail/buffer_sequence_adapter.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/buffer_sequence_adapter.hpp
@@ -1,11 +1,11 @@
 //
 // detail/buffer_sequence_adapter.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_BUFFER_SEQUENCE_ADAPTER_HPP
@@ -26,13 +26,29 @@ namespace boost {
 namespace asio {
 namespace detail {
 
 class buffer_sequence_adapter_base
 {
 protected:
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#if defined(BOOST_ASIO_WINDOWS_RUNTIME)
+  // The maximum number of buffers to support in a single operation.
+  enum { max_buffers = 1 };
+
+  typedef Windows::Storage::Streams::IBuffer^ native_buffer_type;
+
+  BOOST_ASIO_DECL static void init_native_buffer(
+      native_buffer_type& buf,
+      const boost::asio::mutable_buffer& buffer);
+
+  BOOST_ASIO_DECL static void init_native_buffer(
+      native_buffer_type& buf,
+      const boost::asio::const_buffer& buffer);
+#elif defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
+  // The maximum number of buffers to support in a single operation.
+  enum { max_buffers = 64 < max_iov_len ? 64 : max_iov_len };
+
   typedef WSABUF native_buffer_type;
 
   static void init_native_buffer(WSABUF& buf,
       const boost::asio::mutable_buffer& buffer)
   {
     buf.buf = boost::asio::buffer_cast<char*>(buffer);
@@ -42,13 +58,16 @@ protected:
   static void init_native_buffer(WSABUF& buf,
       const boost::asio::const_buffer& buffer)
   {
     buf.buf = const_cast<char*>(boost::asio::buffer_cast<const char*>(buffer));
     buf.len = static_cast<ULONG>(boost::asio::buffer_size(buffer));
   }
-#else // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
+  // The maximum number of buffers to support in a single operation.
+  enum { max_buffers = 64 < max_iov_len ? 64 : max_iov_len };
+
   typedef iovec native_buffer_type;
 
   static void init_iov_base(void*& base, void* addr)
   {
     base = addr;
   }
@@ -70,13 +89,13 @@ protected:
       const boost::asio::const_buffer& buffer)
   {
     init_iov_base(iov.iov_base, const_cast<void*>(
           boost::asio::buffer_cast<const void*>(buffer)));
     iov.iov_len = boost::asio::buffer_size(buffer);
   }
-#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 };
 
 // Helper class to translate buffers into the native buffer representation.
 template <typename Buffer, typename Buffers>
 class buffer_sequence_adapter
   : buffer_sequence_adapter_base
@@ -143,15 +162,12 @@ public:
         return buffer;
     }
     return Buffer();
   }
 
 private:
-  // The maximum number of buffers to support in a single operation.
-  enum { max_buffers = 64 < max_iov_len ? 64 : max_iov_len };
-
   native_buffer_type buffers_[max_buffers];
   std::size_t count_;
   std::size_t total_buffer_size_;
 };
 
 template <typename Buffer>
@@ -359,7 +375,11 @@ private:
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
+#if defined(BOOST_ASIO_HEADER_ONLY)
+# include <boost/asio/detail/impl/buffer_sequence_adapter.ipp>
+#endif // defined(BOOST_ASIO_HEADER_ONLY)
+
 #endif // BOOST_ASIO_DETAIL_BUFFER_SEQUENCE_ADAPTER_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/buffered_stream_storage.hpp b/3rdParty/Boost/src/boost/asio/detail/buffered_stream_storage.hpp
index 3c7ba71..6f138d2 100644
--- a/3rdParty/Boost/src/boost/asio/detail/buffered_stream_storage.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/buffered_stream_storage.hpp
@@ -1,11 +1,11 @@
 //
 // detail/buffered_stream_storage.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_BUFFERED_STREAM_STORAGE_HPP
@@ -14,13 +14,13 @@
 #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/buffer.hpp>
-#include <boost/assert.hpp>
+#include <boost/asio/detail/assert.hpp>
 #include <cstddef>
 #include <cstring>
 #include <vector>
 
 #include <boost/asio/detail/push_options.hpp>
 
@@ -76,13 +76,13 @@ public:
     return end_offset_ - begin_offset_;
   }
 
   // Resize the buffer to the specified length.
   void resize(size_type length)
   {
-    BOOST_ASSERT(length <= capacity());
+    BOOST_ASIO_ASSERT(length <= capacity());
     if (begin_offset_ + length <= capacity())
     {
       end_offset_ = begin_offset_ + length;
     }
     else
     {
@@ -99,13 +99,13 @@ public:
     return buffer_.size();
   }
 
   // Consume multiple bytes from the beginning of the buffer.
   void consume(size_type count)
   {
-    BOOST_ASSERT(begin_offset_ + count <= end_offset_);
+    BOOST_ASIO_ASSERT(begin_offset_ + count <= end_offset_);
     begin_offset_ += count;
     if (empty())
       clear();
   }
 
 private:
diff --git a/3rdParty/Boost/src/boost/asio/detail/call_stack.hpp b/3rdParty/Boost/src/boost/asio/detail/call_stack.hpp
index db4cd1e..62aeb40 100644
--- a/3rdParty/Boost/src/boost/asio/detail/call_stack.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/call_stack.hpp
@@ -1,11 +1,11 @@
 //
 // detail/call_stack.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_CALL_STACK_HPP
@@ -99,12 +99,19 @@ public:
         return elem->value_;
       elem = elem->next_;
     }
     return 0;
   }
 
+  // Obtain the value at the top of the stack.
+  static Value* top()
+  {
+    context* elem = top_;
+    return elem ? elem->value_ : 0;
+  }
+
 private:
   // The top of the stack of calls for the current thread.
   static tss_ptr<context> top_;
 };
 
 template <typename Key, typename Value>
diff --git a/3rdParty/Boost/src/boost/asio/detail/chrono_time_traits.hpp b/3rdParty/Boost/src/boost/asio/detail/chrono_time_traits.hpp
index e56c8c3..6b81e5d 100644
--- a/3rdParty/Boost/src/boost/asio/detail/chrono_time_traits.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/chrono_time_traits.hpp
@@ -1,31 +1,38 @@
 //
 // detail/chrono_time_traits.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_CHRONO_TIME_TRAITS_HPP
 #define BOOST_ASIO_DETAIL_CHRONO_TIME_TRAITS_HPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
-#include <boost/cstdint.hpp>
+#include <boost/asio/detail/cstdint.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
+// Helper template to compute the greatest common divisor.
+template <int64_t v1, int64_t v2>
+struct gcd { enum { value = gcd<v2, v1 % v2>::value }; };
+
+template <int64_t v1>
+struct gcd<v1, 0> { enum { value = v1 }; };
+
 // Adapts std::chrono clocks for use with a deadline timer.
 template <typename Clock, typename WaitTraits>
 struct chrono_time_traits
 {
   // The clock type.
   typedef Clock clock_type;
@@ -45,19 +52,69 @@ struct chrono_time_traits
     return clock_type::now();
   }
 
   // Add a duration to a time.
   static time_type add(const time_type& t, const duration_type& d)
   {
+    const time_type epoch;
+    if (t >= epoch)
+    {
+      if ((time_type::max)() - t < d)
+        return (time_type::max)();
+    }
+    else // t < epoch
+    {
+      if (-(t - (time_type::min)()) > d)
+        return (time_type::min)();
+    }
+
     return t + d;
   }
 
   // Subtract one time from another.
   static duration_type subtract(const time_type& t1, const time_type& t2)
   {
-    return t1 - t2;
+    const time_type epoch;
+    if (t1 >= epoch)
+    {
+      if (t2 >= epoch)
+      {
+        return t1 - t2;
+      }
+      else if (t2 == (time_type::min)())
+      {
+        return (duration_type::max)();
+      }
+      else if ((time_type::max)() - t1 < epoch - t2)
+      {
+        return (duration_type::max)();
+      }
+      else
+      {
+        return t1 - t2;
+      }
+    }
+    else // t1 < epoch
+    {
+      if (t2 < epoch)
+      {
+        return t1 - t2;
+      }
+      else if (t1 == (time_type::min)())
+      {
+        return (duration_type::min)();
+      }
+      else if ((time_type::max)() - t2 < epoch - t1)
+      {
+        return (duration_type::min)();
+      }
+      else
+      {
+        return -(t2 - t1);
+      }
+    }
   }
 
   // Test whether one time is less than another.
   static bool less_than(const time_type& t1, const time_type& t2)
   {
     return t1 < t2;
@@ -70,38 +127,44 @@ struct chrono_time_traits
   public:
     explicit posix_time_duration(const duration_type& d)
       : d_(d)
     {
     }
 
-    boost::int64_t ticks() const
+    int64_t ticks() const
     {
       return d_.count();
     }
 
-    boost::int64_t total_seconds() const
+    int64_t total_seconds() const
     {
       return duration_cast<1, 1>();
     }
 
-    boost::int64_t total_milliseconds() const
+    int64_t total_milliseconds() const
     {
       return duration_cast<1, 1000>();
     }
 
-    boost::int64_t total_microseconds() const
+    int64_t total_microseconds() const
     {
       return duration_cast<1, 1000000>();
     }
 
   private:
-    template <boost::int64_t Num, boost::int64_t Den>
-    boost::int64_t duration_cast() const
+    template <int64_t Num, int64_t Den>
+    int64_t duration_cast() const
     {
-      const boost::int64_t num = period_type::num * Den;
-      const boost::int64_t den = period_type::den * Num;
+      const int64_t num1 = period_type::num / gcd<period_type::num, Num>::value;
+      const int64_t num2 = Num / gcd<period_type::num, Num>::value;
+
+      const int64_t den1 = period_type::den / gcd<period_type::den, Den>::value;
+      const int64_t den2 = Den / gcd<period_type::den, Den>::value;
+
+      const int64_t num = num1 * den2;
+      const int64_t den = num2 * den1;
 
       if (num == 1 && den == 1)
         return ticks();
       else if (num != 1 && den == 1)
         return ticks() * num;
       else if (num == 1 && period_type::den != 1)
diff --git a/3rdParty/Boost/src/boost/asio/detail/completion_handler.hpp b/3rdParty/Boost/src/boost/asio/detail/completion_handler.hpp
index 19b4360..833f5a3 100644
--- a/3rdParty/Boost/src/boost/asio/detail/completion_handler.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/completion_handler.hpp
@@ -1,23 +1,24 @@
 //
 // detail/completion_handler.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_COMPLETION_HANDLER_HPP
 #define BOOST_ASIO_DETAIL_COMPLETION_HANDLER_HPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
+#include <boost/asio/detail/addressof.hpp>
 #include <boost/asio/detail/config.hpp>
 #include <boost/asio/detail/fenced_block.hpp>
 #include <boost/asio/detail/handler_alloc_helpers.hpp>
 #include <boost/asio/detail/handler_invoke_helpers.hpp>
 #include <boost/asio/detail/operation.hpp>
 
@@ -42,24 +43,24 @@ public:
   static void do_complete(io_service_impl* owner, operation* base,
       const boost::system::error_code& /*ec*/,
       std::size_t /*bytes_transferred*/)
   {
     // Take ownership of the handler object.
     completion_handler* h(static_cast<completion_handler*>(base));
-    ptr p = { boost::addressof(h->handler_), h, h };
+    ptr p = { boost::asio::detail::addressof(h->handler_), h, h };
 
     BOOST_ASIO_HANDLER_COMPLETION((h));
 
     // Make a copy of the handler so that the memory can be deallocated before
     // the upcall is made. Even if we're not about to make an upcall, a
     // sub-object of the handler may be the true owner of the memory associated
     // with the handler. Consequently, a local copy of the handler is required
     // to ensure that any owning sub-object remains valid until after we have
     // deallocated the memory here.
     Handler handler(BOOST_ASIO_MOVE_CAST(Handler)(h->handler_));
-    p.h = boost::addressof(handler);
+    p.h = boost::asio::detail::addressof(handler);
     p.reset();
 
     // Make the upcall if required.
     if (owner)
     {
       fenced_block b(fenced_block::half);
diff --git a/3rdParty/Boost/src/boost/asio/detail/config.hpp b/3rdParty/Boost/src/boost/asio/detail/config.hpp
index c47c007..453f04d 100644
--- a/3rdParty/Boost/src/boost/asio/detail/config.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/config.hpp
@@ -1,72 +1,120 @@
 //
 // detail/config.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_CONFIG_HPP
 #define BOOST_ASIO_DETAIL_CONFIG_HPP
 
-#include <boost/config.hpp>
-#include <boost/version.hpp>
+#if defined(BOOST_ASIO_STANDALONE)
+# define BOOST_ASIO_DISABLE_BOOST_ARRAY 1
+# define BOOST_ASIO_DISABLE_BOOST_ASSERT 1
+# define BOOST_ASIO_DISABLE_BOOST_BIND 1
+# define BOOST_ASIO_DISABLE_BOOST_CHRONO 1
+# define BOOST_ASIO_DISABLE_BOOST_DATE_TIME 1
+# define BOOST_ASIO_DISABLE_BOOST_LIMITS 1
+# define BOOST_ASIO_DISABLE_BOOST_REGEX 1
+# define BOOST_ASIO_DISABLE_BOOST_STATIC_CONSTANT 1
+# define BOOST_ASIO_DISABLE_BOOST_THROW_EXCEPTION 1
+# define BOOST_ASIO_DISABLE_BOOST_WORKAROUND 1
+#else // defined(BOOST_ASIO_STANDALONE)
+# include <boost/config.hpp>
+# include <boost/version.hpp>
+# define BOOST_ASIO_HAS_BOOST_CONFIG 1
+#endif // defined(BOOST_ASIO_STANDALONE)
 
 // Default to a header-only implementation. The user must specifically request
 // separate compilation by defining either BOOST_ASIO_SEPARATE_COMPILATION or
 // BOOST_ASIO_DYN_LINK (as a DLL/shared library implies separate compilation).
 #if !defined(BOOST_ASIO_HEADER_ONLY)
 # if !defined(BOOST_ASIO_SEPARATE_COMPILATION)
 #  if !defined(BOOST_ASIO_DYN_LINK)
-#   define BOOST_ASIO_HEADER_ONLY
+#   define BOOST_ASIO_HEADER_ONLY 1
 #  endif // !defined(BOOST_ASIO_DYN_LINK)
 # endif // !defined(BOOST_ASIO_SEPARATE_COMPILATION)
 #endif // !defined(BOOST_ASIO_HEADER_ONLY)
 
 #if defined(BOOST_ASIO_HEADER_ONLY)
 # define BOOST_ASIO_DECL inline
 #else // defined(BOOST_ASIO_HEADER_ONLY)
-# if defined(BOOST_HAS_DECLSPEC)
+# if defined(_MSC_VER) || defined(__BORLANDC__) || defined(__CODEGEARC__)
 // We need to import/export our code only if the user has specifically asked
 // for it by defining BOOST_ASIO_DYN_LINK.
 #  if defined(BOOST_ASIO_DYN_LINK)
 // Export if this is our own source, otherwise import.
 #   if defined(BOOST_ASIO_SOURCE)
 #    define BOOST_ASIO_DECL __declspec(dllexport)
 #   else // defined(BOOST_ASIO_SOURCE)
 #    define BOOST_ASIO_DECL __declspec(dllimport)
 #   endif // defined(BOOST_ASIO_SOURCE)
 #  endif // defined(BOOST_ASIO_DYN_LINK)
-# endif // defined(BOOST_HAS_DECLSPEC)
+# endif // defined(_MSC_VER) || defined(__BORLANDC__) || defined(__CODEGEARC__)
 #endif // defined(BOOST_ASIO_HEADER_ONLY)
 
 // If BOOST_ASIO_DECL isn't defined yet define it now.
 #if !defined(BOOST_ASIO_DECL)
 # define BOOST_ASIO_DECL
 #endif // !defined(BOOST_ASIO_DECL)
 
+// Microsoft Visual C++ detection.
+#if !defined(BOOST_ASIO_MSVC)
+# if defined(BOOST_ASIO_HAS_BOOST_CONFIG) && defined(BOOST_MSVC)
+#  define BOOST_ASIO_MSVC BOOST_MSVC
+# elif defined(_MSC_VER) && !defined(__MWERKS__) && !defined(__EDG_VERSION__)
+#  define BOOST_ASIO_MSVC _MSC_VER
+# endif // defined(BOOST_ASIO_HAS_BOOST_CONFIG) && defined(BOOST_MSVC)
+#endif // defined(BOOST_ASIO_MSVC)
+
+// Clang / libc++ detection.
+#if defined(__clang__)
+# if (__cplusplus >= 201103)
+#  if __has_include(<__config>)
+#   include <__config>
+#   if defined(_LIBCPP_VERSION)
+#    define BOOST_ASIO_HAS_CLANG_LIBCXX 1
+#   endif // defined(_LIBCPP_VERSION)
+#  endif // __has_include(<__config>)
+# endif // (__cplusplus >= 201103)
+#endif // defined(__clang__)
+
 // Support move construction and assignment on compilers known to allow it.
-#if !defined(BOOST_ASIO_DISABLE_MOVE)
-# if defined(__GNUC__)
-#  if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)) || (__GNUC__ > 4)
-#   if defined(__GXX_EXPERIMENTAL_CXX0X__)
-#    define BOOST_ASIO_HAS_MOVE
-#   endif // defined(__GXX_EXPERIMENTAL_CXX0X__)
-#  endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)) || (__GNUC__ > 4)
-# endif // defined(__GNUC__)
-#endif // !defined(BOOST_ASIO_DISABLE_MOVE)
+#if !defined(BOOST_ASIO_HAS_MOVE)
+# if !defined(BOOST_ASIO_DISABLE_MOVE)
+#  if defined(__clang__)
+#   if __has_feature(__cxx_rvalue_references__)
+#    define BOOST_ASIO_HAS_MOVE 1
+#   endif // __has_feature(__cxx_rvalue_references__)
+#  endif // defined(__clang__)
+#  if defined(__GNUC__)
+#   if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)) || (__GNUC__ > 4)
+#    if defined(__GXX_EXPERIMENTAL_CXX0X__)
+#     define BOOST_ASIO_HAS_MOVE 1
+#    endif // defined(__GXX_EXPERIMENTAL_CXX0X__)
+#   endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)) || (__GNUC__ > 4)
+#  endif // defined(__GNUC__)
+#  if defined(BOOST_ASIO_MSVC)
+#   if (_MSC_VER >= 1700)
+#    define BOOST_ASIO_HAS_MOVE 1
+#   endif // (_MSC_VER >= 1700)
+#  endif // defined(BOOST_ASIO_MSVC)
+# endif // !defined(BOOST_ASIO_DISABLE_MOVE)
+#endif // !defined(BOOST_ASIO_HAS_MOVE)
 
 // If BOOST_ASIO_MOVE_CAST isn't defined, and move support is available, define
 // BOOST_ASIO_MOVE_ARG and BOOST_ASIO_MOVE_CAST to take advantage of rvalue
 // references and perfect forwarding.
 #if defined(BOOST_ASIO_HAS_MOVE) && !defined(BOOST_ASIO_MOVE_CAST)
 # define BOOST_ASIO_MOVE_ARG(type) type&&
 # define BOOST_ASIO_MOVE_CAST(type) static_cast<type&&>
+# define BOOST_ASIO_MOVE_CAST2(type1, type2) static_cast<type1, type2&&>
 #endif // defined(BOOST_ASIO_HAS_MOVE) && !defined(BOOST_ASIO_MOVE_CAST)
 
 // If BOOST_ASIO_MOVE_CAST still isn't defined, default to a C++03-compatible
 // implementation. Note that older g++ and MSVC versions don't like it when you
 // pass a non-member function through a const reference, so for most compilers
 // we'll play it safe and stick with the old approach of passing the handler by
@@ -75,128 +123,361 @@
 # if defined(__GNUC__)
 #  if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 1)) || (__GNUC__ > 4)
 #   define BOOST_ASIO_MOVE_ARG(type) const type&
 #  else // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 1)) || (__GNUC__ > 4)
 #   define BOOST_ASIO_MOVE_ARG(type) type
 #  endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 1)) || (__GNUC__ > 4)
-# elif defined(BOOST_MSVC)
+# elif defined(BOOST_ASIO_MSVC)
 #  if (_MSC_VER >= 1400)
 #   define BOOST_ASIO_MOVE_ARG(type) const type&
 #  else // (_MSC_VER >= 1400)
 #   define BOOST_ASIO_MOVE_ARG(type) type
 #  endif // (_MSC_VER >= 1400)
 # else
 #  define BOOST_ASIO_MOVE_ARG(type) type
 # endif
 # define BOOST_ASIO_MOVE_CAST(type) static_cast<const type&>
-#endif // !defined_BOOST_ASIO_MOVE_CAST
+# define BOOST_ASIO_MOVE_CAST2(type1, type2) static_cast<const type1, type2&>
+#endif // !defined(BOOST_ASIO_MOVE_CAST)
 
 // Support variadic templates on compilers known to allow it.
-#if !defined(BOOST_ASIO_DISABLE_VARIADIC_TEMPLATES)
-# if defined(__GNUC__)
-#  if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 4)
-#   if defined(__GXX_EXPERIMENTAL_CXX0X__)
-#    define BOOST_ASIO_HAS_VARIADIC_TEMPLATES
-#   endif // defined(__GXX_EXPERIMENTAL_CXX0X__)
-#  endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 4)
-# endif // defined(__GNUC__)
-#endif // !defined(BOOST_ASIO_DISABLE_VARIADIC_TEMPLATES)
+#if !defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+# if !defined(BOOST_ASIO_DISABLE_VARIADIC_TEMPLATES)
+#  if defined(__clang__)
+#   if __has_feature(__cxx_variadic_templates__)
+#    define BOOST_ASIO_HAS_VARIADIC_TEMPLATES 1
+#   endif // __has_feature(__cxx_variadic_templates__)
+#  endif // defined(__clang__)
+#  if defined(__GNUC__)
+#   if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 4)
+#    if defined(__GXX_EXPERIMENTAL_CXX0X__)
+#     define BOOST_ASIO_HAS_VARIADIC_TEMPLATES 1
+#    endif // defined(__GXX_EXPERIMENTAL_CXX0X__)
+#   endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 4)
+#  endif // defined(__GNUC__)
+# endif // !defined(BOOST_ASIO_DISABLE_VARIADIC_TEMPLATES)
+#endif // !defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+// Support constexpr on compilers known to allow it.
+#if !defined(BOOST_ASIO_HAS_CONSTEXPR)
+# if !defined(BOOST_ASIO_DISABLE_CONSTEXPR)
+#  if defined(__clang__)
+#   if __has_feature(__cxx_constexpr__)
+#    define BOOST_ASIO_HAS_CONSTEXPR 1
+#   endif // __has_feature(__cxx_constexr__)
+#  endif // defined(__clang__)
+#  if defined(__GNUC__)
+#   if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 6)) || (__GNUC__ > 4)
+#    if defined(__GXX_EXPERIMENTAL_CXX0X__)
+#     define BOOST_ASIO_HAS_CONSTEXPR 1
+#    endif // defined(__GXX_EXPERIMENTAL_CXX0X__)
+#   endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 6)) || (__GNUC__ > 4)
+#  endif // defined(__GNUC__)
+# endif // !defined(BOOST_ASIO_DISABLE_CONSTEXPR)
+#endif // !defined(BOOST_ASIO_HAS_CONSTEXPR)
+#if !defined(BOOST_ASIO_CONSTEXPR)
+# if defined(BOOST_ASIO_HAS_CONSTEXPR)
+#  define BOOST_ASIO_CONSTEXPR constexpr
+# else // defined(BOOST_ASIO_HAS_CONSTEXPR)
+#  define BOOST_ASIO_CONSTEXPR
+# endif // defined(BOOST_ASIO_HAS_CONSTEXPR)
+#endif // !defined(BOOST_ASIO_CONSTEXPR)
 
 // Standard library support for system errors.
-#if !defined(BOOST_ASIO_DISABLE_STD_SYSTEM_ERROR)
-# if defined(__GNUC__)
-#  if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 6)) || (__GNUC__ > 4)
-#   if defined(__GXX_EXPERIMENTAL_CXX0X__)
-#    define BOOST_ASIO_HAS_STD_SYSTEM_ERROR
-#   endif // defined(__GXX_EXPERIMENTAL_CXX0X__)
-#  endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 6)) || (__GNUC__ > 4)
-# endif // defined(__GNUC__)
-#endif // !defined(BOOST_ASIO_DISABLE_STD_SYSTEM_ERROR)
+# if !defined(BOOST_ASIO_DISABLE_STD_SYSTEM_ERROR)
+#  if defined(BOOST_ASIO_HAS_CLANG_LIBCXX)
+#   define BOOST_ASIO_HAS_STD_SYSTEM_ERROR 1
+#  endif // defined(BOOST_ASIO_HAS_CLANG_LIBCXX)
+#  if defined(__GNUC__)
+#   if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 6)) || (__GNUC__ > 4)
+#    if defined(__GXX_EXPERIMENTAL_CXX0X__)
+#     define BOOST_ASIO_HAS_STD_SYSTEM_ERROR 1
+#    endif // defined(__GXX_EXPERIMENTAL_CXX0X__)
+#   endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 6)) || (__GNUC__ > 4)
+#  endif // defined(__GNUC__)
+#  if defined(BOOST_ASIO_MSVC)
+#   if (_MSC_VER >= 1700)
+#    define BOOST_ASIO_HAS_STD_SYSTEM_ERROR 1
+#   endif // (_MSC_VER >= 1700)
+#  endif // defined(BOOST_ASIO_MSVC)
+# endif // !defined(BOOST_ASIO_DISABLE_STD_SYSTEM_ERROR)
 
 // Compliant C++11 compilers put noexcept specifiers on error_category members.
 #if !defined(BOOST_ASIO_ERROR_CATEGORY_NOEXCEPT)
-# if defined(__GNUC__)
+# if (BOOST_VERSION >= 105300)
+#  define BOOST_ASIO_ERROR_CATEGORY_NOEXCEPT BOOST_NOEXCEPT
+# elif defined(__clang__)
+#  if __has_feature(__cxx_noexcept__)
+#   define BOOST_ASIO_ERROR_CATEGORY_NOEXCEPT noexcept(true)
+#  endif // __has_feature(__cxx_noexcept__)
+# elif defined(__GNUC__)
 #  if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) || (__GNUC__ > 4)
 #   if defined(__GXX_EXPERIMENTAL_CXX0X__)
 #     define BOOST_ASIO_ERROR_CATEGORY_NOEXCEPT noexcept(true)
 #   endif // defined(__GXX_EXPERIMENTAL_CXX0X__)
 #  endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) || (__GNUC__ > 4)
 # endif // defined(__GNUC__)
 # if !defined(BOOST_ASIO_ERROR_CATEGORY_NOEXCEPT)
 #  define BOOST_ASIO_ERROR_CATEGORY_NOEXCEPT
 # endif // !defined(BOOST_ASIO_ERROR_CATEGORY_NOEXCEPT)
 #endif // !defined(BOOST_ASIO_ERROR_CATEGORY_NOEXCEPT)
 
 // Standard library support for arrays.
-#if !defined(BOOST_ASIO_DISABLE_STD_ARRAY)
-# if defined(__GNUC__)
-#  if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 4)
-#   if defined(__GXX_EXPERIMENTAL_CXX0X__)
-#    define BOOST_ASIO_HAS_STD_ARRAY
-#   endif // defined(__GXX_EXPERIMENTAL_CXX0X__)
-#  endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 4)
-# endif // defined(__GNUC__)
-# if defined(BOOST_MSVC)
-#  if (_MSC_VER >= 1600)
-#   define BOOST_ASIO_HAS_STD_ARRAY
-#  endif // (_MSC_VER >= 1600)
-# endif // defined(BOOST_MSVC)
-#endif // !defined(BOOST_ASIO_DISABLE_STD_ARRAY)
+#if !defined(BOOST_ASIO_HAS_STD_ARRAY)
+# if !defined(BOOST_ASIO_DISABLE_STD_ARRAY)
+#  if defined(BOOST_ASIO_HAS_CLANG_LIBCXX)
+#   define BOOST_ASIO_HAS_STD_ARRAY 1
+#  endif // defined(BOOST_ASIO_HAS_CLANG_LIBCXX)
+#  if defined(__GNUC__)
+#   if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 4)
+#    if defined(__GXX_EXPERIMENTAL_CXX0X__)
+#     define BOOST_ASIO_HAS_STD_ARRAY 1
+#    endif // defined(__GXX_EXPERIMENTAL_CXX0X__)
+#   endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 4)
+#  endif // defined(__GNUC__)
+#  if defined(BOOST_ASIO_MSVC)
+#   if (_MSC_VER >= 1600)
+#    define BOOST_ASIO_HAS_STD_ARRAY 1
+#   endif // (_MSC_VER >= 1600)
+#  endif // defined(BOOST_ASIO_MSVC)
+# endif // !defined(BOOST_ASIO_DISABLE_STD_ARRAY)
+#endif // !defined(BOOST_ASIO_HAS_STD_ARRAY)
 
 // Standard library support for shared_ptr and weak_ptr.
-#if !defined(BOOST_ASIO_DISABLE_STD_SHARED_PTR)
-# if defined(__GNUC__)
-#  if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 4)
-#   if defined(__GXX_EXPERIMENTAL_CXX0X__)
-#    define BOOST_ASIO_HAS_STD_SHARED_PTR
-#   endif // defined(__GXX_EXPERIMENTAL_CXX0X__)
-#  endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 4)
-# endif // defined(__GNUC__)
-# if defined(BOOST_MSVC)
-#  if (_MSC_VER >= 1600)
-#   define BOOST_ASIO_HAS_STD_SHARED_PTR
-#  endif // (_MSC_VER >= 1600)
-# endif // defined(BOOST_MSVC)
-#endif // !defined(BOOST_ASIO_DISABLE_STD_SHARED_PTR)
+#if !defined(BOOST_ASIO_HAS_STD_SHARED_PTR)
+# if !defined(BOOST_ASIO_DISABLE_STD_SHARED_PTR)
+#  if defined(BOOST_ASIO_HAS_CLANG_LIBCXX)
+#   define BOOST_ASIO_HAS_STD_SHARED_PTR 1
+#  endif // defined(BOOST_ASIO_HAS_CLANG_LIBCXX)
+#  if defined(__GNUC__)
+#   if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 4)
+#    if defined(__GXX_EXPERIMENTAL_CXX0X__)
+#     define BOOST_ASIO_HAS_STD_SHARED_PTR 1
+#    endif // defined(__GXX_EXPERIMENTAL_CXX0X__)
+#   endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 4)
+#  endif // defined(__GNUC__)
+#  if defined(BOOST_ASIO_MSVC)
+#   if (_MSC_VER >= 1600)
+#    define BOOST_ASIO_HAS_STD_SHARED_PTR 1
+#   endif // (_MSC_VER >= 1600)
+#  endif // defined(BOOST_ASIO_MSVC)
+# endif // !defined(BOOST_ASIO_DISABLE_STD_SHARED_PTR)
+#endif // !defined(BOOST_ASIO_HAS_STD_SHARED_PTR)
 
 // Standard library support for atomic operations.
-#if !defined(BOOST_ASIO_DISABLE_STD_ATOMIC)
-# if defined(__GNUC__)
-#  if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)) || (__GNUC__ > 4)
-#   if defined(__GXX_EXPERIMENTAL_CXX0X__)
-#    define BOOST_ASIO_HAS_STD_ATOMIC
-#   endif // defined(__GXX_EXPERIMENTAL_CXX0X__)
-#  endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)) || (__GNUC__ > 4)
-# endif // defined(__GNUC__)
-#endif // !defined(BOOST_ASIO_DISABLE_STD_ATOMIC)
+#if !defined(BOOST_ASIO_HAS_STD_ATOMIC)
+# if !defined(BOOST_ASIO_DISABLE_STD_ATOMIC)
+#  if defined(BOOST_ASIO_HAS_CLANG_LIBCXX)
+#   define BOOST_ASIO_HAS_STD_ATOMIC 1
+#  endif // defined(BOOST_ASIO_HAS_CLANG_LIBCXX)
+#  if defined(__GNUC__)
+#   if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)) || (__GNUC__ > 4)
+#    if defined(__GXX_EXPERIMENTAL_CXX0X__)
+#     define BOOST_ASIO_HAS_STD_ATOMIC 1
+#    endif // defined(__GXX_EXPERIMENTAL_CXX0X__)
+#   endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)) || (__GNUC__ > 4)
+#  endif // defined(__GNUC__)
+#  if defined(BOOST_ASIO_MSVC)
+#   if (_MSC_VER >= 1700)
+#    define BOOST_ASIO_HAS_STD_ATOMIC 1
+#   endif // (_MSC_VER >= 1700)
+#  endif // defined(BOOST_ASIO_MSVC)
+# endif // !defined(BOOST_ASIO_DISABLE_STD_ATOMIC)
+#endif // !defined(BOOST_ASIO_HAS_STD_ATOMIC)
 
 // Standard library support for chrono. Some standard libraries (such as the
 // libstdc++ shipped with gcc 4.6) provide monotonic_clock as per early C++0x
 // drafts, rather than the eventually standardised name of steady_clock.
-#if !defined(BOOST_ASIO_DISABLE_STD_CHRONO)
-# if defined(__GNUC__)
-#  if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 6)) || (__GNUC__ > 4)
-#   if defined(__GXX_EXPERIMENTAL_CXX0X__)
-#    define BOOST_ASIO_HAS_STD_CHRONO
-#    if ((__GNUC__ == 4) && (__GNUC_MINOR__ == 6))
-#     define BOOST_ASIO_HAS_STD_CHRONO_MONOTONIC_CLOCK
-#    endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ == 6))
-#   endif // defined(__GXX_EXPERIMENTAL_CXX0X__)
-#  endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 6)) || (__GNUC__ > 4)
-# endif // defined(__GNUC__)
-#endif // !defined(BOOST_ASIO_DISABLE_STD_CHRONO)
+#if !defined(BOOST_ASIO_HAS_STD_CHRONO)
+# if !defined(BOOST_ASIO_DISABLE_STD_CHRONO)
+#  if defined(BOOST_ASIO_HAS_CLANG_LIBCXX)
+#   define BOOST_ASIO_HAS_STD_CHRONO 1
+#  endif // defined(BOOST_ASIO_HAS_CLANG_LIBCXX)
+#  if defined(__GNUC__)
+#   if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 6)) || (__GNUC__ > 4)
+#    if defined(__GXX_EXPERIMENTAL_CXX0X__)
+#     define BOOST_ASIO_HAS_STD_CHRONO 1
+#     if ((__GNUC__ == 4) && (__GNUC_MINOR__ == 6))
+#      define BOOST_ASIO_HAS_STD_CHRONO_MONOTONIC_CLOCK 1
+#     endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ == 6))
+#    endif // defined(__GXX_EXPERIMENTAL_CXX0X__)
+#   endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 6)) || (__GNUC__ > 4)
+#  endif // defined(__GNUC__)
+#  if defined(BOOST_ASIO_MSVC)
+#   if (_MSC_VER >= 1700)
+#    define BOOST_ASIO_HAS_STD_CHRONO 1
+#   endif // (_MSC_VER >= 1700)
+#  endif // defined(BOOST_ASIO_MSVC)
+# endif // !defined(BOOST_ASIO_DISABLE_STD_CHRONO)
+#endif // !defined(BOOST_ASIO_HAS_STD_CHRONO)
 
 // Boost support for chrono.
-#if !defined(BOOST_ASIO_DISABLE_BOOST_CHRONO)
-# if (BOOST_VERSION >= 104700)
-#  define BOOST_ASIO_HAS_BOOST_CHRONO
-#   endif // (BOOST_VERSION >= 104700)
-#endif // !defined(BOOST_ASIO_DISABLE_BOOST_CHRONO)
+#if !defined(BOOST_ASIO_HAS_BOOST_CHRONO)
+# if !defined(BOOST_ASIO_DISABLE_BOOST_CHRONO)
+#  if (BOOST_VERSION >= 104700)
+#   define BOOST_ASIO_HAS_BOOST_CHRONO 1
+#  endif // (BOOST_VERSION >= 104700)
+# endif // !defined(BOOST_ASIO_DISABLE_BOOST_CHRONO)
+#endif // !defined(BOOST_ASIO_HAS_BOOST_CHRONO)
+
+// Boost support for the DateTime library.
+#if !defined(BOOST_ASIO_HAS_BOOST_DATE_TIME)
+# if !defined(BOOST_ASIO_DISABLE_BOOST_DATE_TIME)
+#  define BOOST_ASIO_HAS_BOOST_DATE_TIME 1
+# endif // !defined(BOOST_ASIO_DISABLE_BOOST_DATE_TIME)
+#endif // !defined(BOOST_ASIO_HAS_BOOST_DATE_TIME)
+
+// Standard library support for addressof.
+#if !defined(BOOST_ASIO_HAS_STD_ADDRESSOF)
+# if !defined(BOOST_ASIO_DISABLE_STD_ADDRESSOF)
+#  if defined(BOOST_ASIO_HAS_CLANG_LIBCXX)
+#   define BOOST_ASIO_HAS_STD_ADDRESSOF 1
+#  endif // defined(BOOST_ASIO_HAS_CLANG_LIBCXX)
+#  if defined(__GNUC__)
+#   if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)) || (__GNUC__ > 4)
+#    if defined(__GXX_EXPERIMENTAL_CXX0X__)
+#     define BOOST_ASIO_HAS_STD_ADDRESSOF 1
+#    endif // defined(__GXX_EXPERIMENTAL_CXX0X__)
+#   endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)) || (__GNUC__ > 4)
+#  endif // defined(__GNUC__)
+#  if defined(BOOST_ASIO_MSVC)
+#   if (_MSC_VER >= 1700)
+#    define BOOST_ASIO_HAS_STD_ADDRESSOF 1
+#   endif // (_MSC_VER >= 1700)
+#  endif // defined(BOOST_ASIO_MSVC)
+# endif // !defined(BOOST_ASIO_DISABLE_STD_ADDRESSOF)
+#endif // !defined(BOOST_ASIO_HAS_STD_ADDRESSOF)
+
+// Standard library support for the function class.
+#if !defined(BOOST_ASIO_HAS_STD_FUNCTION)
+# if !defined(BOOST_ASIO_DISABLE_STD_FUNCTION)
+#  if defined(BOOST_ASIO_HAS_CLANG_LIBCXX)
+#   define BOOST_ASIO_HAS_STD_FUNCTION 1
+#  endif // defined(BOOST_ASIO_HAS_CLANG_LIBCXX)
+#  if defined(__GNUC__)
+#   if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)) || (__GNUC__ > 4)
+#    if defined(__GXX_EXPERIMENTAL_CXX0X__)
+#     define BOOST_ASIO_HAS_STD_FUNCTION 1
+#    endif // defined(__GXX_EXPERIMENTAL_CXX0X__)
+#   endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)) || (__GNUC__ > 4)
+#  endif // defined(__GNUC__)
+#  if defined(BOOST_ASIO_MSVC)
+#   if (_MSC_VER >= 1700)
+#    define BOOST_ASIO_HAS_STD_FUNCTION 1
+#   endif // (_MSC_VER >= 1700)
+#  endif // defined(BOOST_ASIO_MSVC)
+# endif // !defined(BOOST_ASIO_DISABLE_STD_FUNCTION)
+#endif // !defined(BOOST_ASIO_HAS_STD_FUNCTION)
+
+// Standard library support for type traits.
+#if !defined(BOOST_ASIO_HAS_STD_TYPE_TRAITS)
+# if !defined(BOOST_ASIO_DISABLE_STD_TYPE_TRAITS)
+#  if defined(BOOST_ASIO_HAS_CLANG_LIBCXX)
+#   define BOOST_ASIO_HAS_STD_TYPE_TRAITS 1
+#  endif // defined(BOOST_ASIO_HAS_CLANG_LIBCXX)
+#  if defined(__GNUC__)
+#   if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)) || (__GNUC__ > 4)
+#    if defined(__GXX_EXPERIMENTAL_CXX0X__)
+#     define BOOST_ASIO_HAS_STD_TYPE_TRAITS 1
+#    endif // defined(__GXX_EXPERIMENTAL_CXX0X__)
+#   endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)) || (__GNUC__ > 4)
+#  endif // defined(__GNUC__)
+#  if defined(BOOST_ASIO_MSVC)
+#   if (_MSC_VER >= 1700)
+#    define BOOST_ASIO_HAS_STD_TYPE_TRAITS 1
+#   endif // (_MSC_VER >= 1700)
+#  endif // defined(BOOST_ASIO_MSVC)
+# endif // !defined(BOOST_ASIO_DISABLE_STD_TYPE_TRAITS)
+#endif // !defined(BOOST_ASIO_HAS_STD_TYPE_TRAITS)
+
+// Standard library support for the cstdint header.
+#if !defined(BOOST_ASIO_HAS_CSTDINT)
+# if !defined(BOOST_ASIO_DISABLE_CSTDINT)
+#  if defined(BOOST_ASIO_HAS_CLANG_LIBCXX)
+#   define BOOST_ASIO_HAS_CSTDINT 1
+#  endif // defined(BOOST_ASIO_HAS_CLANG_LIBCXX)
+#  if defined(__GNUC__)
+#   if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)) || (__GNUC__ > 4)
+#    if defined(__GXX_EXPERIMENTAL_CXX0X__)
+#     define BOOST_ASIO_HAS_CSTDINT 1
+#    endif // defined(__GXX_EXPERIMENTAL_CXX0X__)
+#   endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)) || (__GNUC__ > 4)
+#  endif // defined(__GNUC__)
+#  if defined(BOOST_ASIO_MSVC)
+#   if (_MSC_VER >= 1700)
+#    define BOOST_ASIO_HAS_CSTDINT 1
+#   endif // (_MSC_VER >= 1700)
+#  endif // defined(BOOST_ASIO_MSVC)
+# endif // !defined(BOOST_ASIO_DISABLE_CSTDINT)
+#endif // !defined(BOOST_ASIO_HAS_CSTDINT)
+
+// Standard library support for the thread class.
+#if !defined(BOOST_ASIO_HAS_STD_THREAD)
+# if !defined(BOOST_ASIO_DISABLE_STD_THREAD)
+#  if defined(BOOST_ASIO_HAS_CLANG_LIBCXX)
+#   define BOOST_ASIO_HAS_STD_THREAD 1
+#  endif // defined(BOOST_ASIO_HAS_CLANG_LIBCXX)
+#  if defined(__GNUC__)
+#   if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) || (__GNUC__ > 4)
+#    if defined(__GXX_EXPERIMENTAL_CXX0X__)
+#     define BOOST_ASIO_HAS_STD_THREAD 1
+#    endif // defined(__GXX_EXPERIMENTAL_CXX0X__)
+#   endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) || (__GNUC__ > 4)
+#  endif // defined(__GNUC__)
+#  if defined(BOOST_ASIO_MSVC)
+#   if (_MSC_VER >= 1700)
+#    define BOOST_ASIO_HAS_STD_THREAD 1
+#   endif // (_MSC_VER >= 1700)
+#  endif // defined(BOOST_ASIO_MSVC)
+# endif // !defined(BOOST_ASIO_DISABLE_STD_THREAD)
+#endif // !defined(BOOST_ASIO_HAS_STD_THREAD)
+
+// Standard library support for the mutex and condition variable classes.
+#if !defined(BOOST_ASIO_HAS_STD_MUTEX_AND_CONDVAR)
+# if !defined(BOOST_ASIO_DISABLE_STD_MUTEX_AND_CONDVAR)
+#  if defined(BOOST_ASIO_HAS_CLANG_LIBCXX)
+#   define BOOST_ASIO_HAS_STD_MUTEX_AND_CONDVAR 1
+#  endif // defined(BOOST_ASIO_HAS_CLANG_LIBCXX)
+#  if defined(__GNUC__)
+#   if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) || (__GNUC__ > 4)
+#    if defined(__GXX_EXPERIMENTAL_CXX0X__)
+#     define BOOST_ASIO_HAS_STD_MUTEX_AND_CONDVAR 1
+#    endif // defined(__GXX_EXPERIMENTAL_CXX0X__)
+#   endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) || (__GNUC__ > 4)
+#  endif // defined(__GNUC__)
+#  if defined(BOOST_ASIO_MSVC)
+#   if (_MSC_VER >= 1700)
+#    define BOOST_ASIO_HAS_STD_MUTEX_AND_CONDVAR 1
+#   endif // (_MSC_VER >= 1700)
+#  endif // defined(BOOST_ASIO_MSVC)
+# endif // !defined(BOOST_ASIO_DISABLE_STD_MUTEX_AND_CONDVAR)
+#endif // !defined(BOOST_ASIO_HAS_STD_MUTEX_AND_CONDVAR)
+
+// WinRT target.
+#if !defined(BOOST_ASIO_WINDOWS_RUNTIME)
+# if defined(__cplusplus_winrt)
+#  include <winapifamily.h>
+#  if WINAPI_FAMILY_ONE_PARTITION(WINAPI_FAMILY, WINAPI_PARTITION_APP)
+#   define BOOST_ASIO_WINDOWS_RUNTIME 1
+#  endif // WINAPI_FAMILY_ONE_PARTITION(WINAPI_FAMILY, WINAPI_PARTITION_APP)
+# endif // defined(__cplusplus_winrt)
+#endif // !defined(BOOST_ASIO_WINDOWS_RUNTIME)
+
+// Windows target. Excludes WinRT.
+#if !defined(BOOST_ASIO_WINDOWS)
+# if !defined(BOOST_ASIO_WINDOWS_RUNTIME)
+#  if defined(BOOST_ASIO_HAS_BOOST_CONFIG) && defined(BOOST_WINDOWS)
+#   define BOOST_ASIO_WINDOWS 1
+#  elif defined(WIN32) || defined(_WIN32) || defined(__WIN32__)
+#   define BOOST_ASIO_WINDOWS 1
+#  endif // defined(BOOST_ASIO_HAS_BOOST_CONFIG) && defined(BOOST_WINDOWS)
+# endif // !defined(BOOST_ASIO_WINDOWS_RUNTIME)
+#endif // !defined(BOOST_ASIO_WINDOWS)
 
 // Windows: target OS version.
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 # if !defined(_WIN32_WINNT) && !defined(_WIN32_WINDOWS)
 #  if defined(_MSC_VER) || defined(__BORLANDC__)
 #   pragma message( \
   "Please define _WIN32_WINNT or _WIN32_WINDOWS appropriately. For example:\n"\
   "- add -D_WIN32_WINNT=0x0501 to the compiler command line; or\n"\
   "- add _WIN32_WINNT=0x0501 to your project's Preprocessor Definitions.\n"\
@@ -228,162 +509,398 @@
 # endif // defined(__BORLANDC__)
 # if defined(__CYGWIN__)
 #  if !defined(__USE_W32_SOCKETS)
 #   error You must add -D__USE_W32_SOCKETS to your compiler options.
 #  endif // !defined(__USE_W32_SOCKETS)
 # endif // defined(__CYGWIN__)
-#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 
 // Windows: minimise header inclusion.
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 # if !defined(BOOST_ASIO_NO_WIN32_LEAN_AND_MEAN)
 #  if !defined(WIN32_LEAN_AND_MEAN)
 #   define WIN32_LEAN_AND_MEAN
 #  endif // !defined(WIN32_LEAN_AND_MEAN)
 # endif // !defined(BOOST_ASIO_NO_WIN32_LEAN_AND_MEAN)
-#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 
 // Windows: suppress definition of "min" and "max" macros.
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 # if !defined(BOOST_ASIO_NO_NOMINMAX)
 #  if !defined(NOMINMAX)
 #   define NOMINMAX 1
 #  endif // !defined(NOMINMAX)
 # endif // !defined(BOOST_ASIO_NO_NOMINMAX)
-#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 
 // Windows: IO Completion Ports.
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
-# if defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0400)
-#  if !defined(UNDER_CE)
-#   if !defined(BOOST_ASIO_DISABLE_IOCP)
-#    define BOOST_ASIO_HAS_IOCP 1
-#   endif // !defined(BOOST_ASIO_DISABLE_IOCP)
-#  endif // !defined(UNDER_CE)
-# endif // defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0400)
-#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#if !defined(BOOST_ASIO_HAS_IOCP)
+# if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
+#  if defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0400)
+#   if !defined(UNDER_CE)
+#    if !defined(BOOST_ASIO_DISABLE_IOCP)
+#     define BOOST_ASIO_HAS_IOCP 1
+#    endif // !defined(BOOST_ASIO_DISABLE_IOCP)
+#   endif // !defined(UNDER_CE)
+#  endif // defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0400)
+# endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
+#endif // !defined(BOOST_ASIO_HAS_IOCP)
 
 // Linux: epoll, eventfd and timerfd.
 #if defined(__linux__)
 # include <linux/version.h>
-# if !defined(BOOST_ASIO_DISABLE_EPOLL)
-#  if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,45)
-#   define BOOST_ASIO_HAS_EPOLL 1
-#  endif // LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,45)
-# endif // !defined(BOOST_ASIO_DISABLE_EVENTFD)
-# if !defined(BOOST_ASIO_DISABLE_EVENTFD)
-#  if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22)
-#   define BOOST_ASIO_HAS_EVENTFD 1
-#  endif // LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22)
-# endif // !defined(BOOST_ASIO_DISABLE_EVENTFD)
-# if defined(BOOST_ASIO_HAS_EPOLL)
-#  if (__GLIBC__ > 2) || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 8)
-#   define BOOST_ASIO_HAS_TIMERFD 1
-#  endif // (__GLIBC__ > 2) || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 8)
-# endif // defined(BOOST_ASIO_HAS_EPOLL)
+# if !defined(BOOST_ASIO_HAS_EPOLL)
+#  if !defined(BOOST_ASIO_DISABLE_EPOLL)
+#   if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,45)
+#    define BOOST_ASIO_HAS_EPOLL 1
+#   endif // LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,45)
+#  endif // !defined(BOOST_ASIO_DISABLE_EPOLL)
+# endif // !defined(BOOST_ASIO_HAS_EPOLL)
+# if !defined(BOOST_ASIO_HAS_EVENTFD)
+#  if !defined(BOOST_ASIO_DISABLE_EVENTFD)
+#   if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22)
+#    define BOOST_ASIO_HAS_EVENTFD 1
+#   endif // LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22)
+#  endif // !defined(BOOST_ASIO_DISABLE_EVENTFD)
+# endif // !defined(BOOST_ASIO_HAS_EVENTFD)
+# if !defined(BOOST_ASIO_HAS_TIMERFD)
+#  if defined(BOOST_ASIO_HAS_EPOLL)
+#   if (__GLIBC__ > 2) || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 8)
+#    define BOOST_ASIO_HAS_TIMERFD 1
+#   endif // (__GLIBC__ > 2) || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 8)
+#  endif // defined(BOOST_ASIO_HAS_EPOLL)
+# endif // !defined(BOOST_ASIO_HAS_TIMERFD)
 #endif // defined(__linux__)
 
 // Mac OS X, FreeBSD, NetBSD, OpenBSD: kqueue.
 #if (defined(__MACH__) && defined(__APPLE__)) \
   || defined(__FreeBSD__) \
   || defined(__NetBSD__) \
   || defined(__OpenBSD__)
-# if !defined(BOOST_ASIO_DISABLE_KQUEUE)
-#  define BOOST_ASIO_HAS_KQUEUE 1
-# endif // !defined(BOOST_ASIO_DISABLE_KQUEUE)
+# if !defined(BOOST_ASIO_HAS_KQUEUE)
+#  if !defined(BOOST_ASIO_DISABLE_KQUEUE)
+#   define BOOST_ASIO_HAS_KQUEUE 1
+#  endif // !defined(BOOST_ASIO_DISABLE_KQUEUE)
+# endif // !defined(BOOST_ASIO_HAS_KQUEUE)
 #endif // (defined(__MACH__) && defined(__APPLE__))
        //   || defined(__FreeBSD__)
        //   || defined(__NetBSD__)
        //   || defined(__OpenBSD__)
 
 // Solaris: /dev/poll.
 #if defined(__sun)
-# if !defined(BOOST_ASIO_DISABLE_DEV_POLL)
-#  define BOOST_ASIO_HAS_DEV_POLL 1
-# endif // !defined(BOOST_ASIO_DISABLE_DEV_POLL)
+# if !defined(BOOST_ASIO_HAS_DEV_POLL)
+#  if !defined(BOOST_ASIO_DISABLE_DEV_POLL)
+#   define BOOST_ASIO_HAS_DEV_POLL 1
+#  endif // !defined(BOOST_ASIO_DISABLE_DEV_POLL)
+# endif // !defined(BOOST_ASIO_HAS_DEV_POLL)
 #endif // defined(__sun)
 
 // Serial ports.
-#if defined(BOOST_ASIO_HAS_IOCP) \
-   || !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
-# if !defined(__SYMBIAN32__)
-#  if !defined(BOOST_ASIO_DISABLE_SERIAL_PORT)
-#   define BOOST_ASIO_HAS_SERIAL_PORT 1
-#  endif // !defined(BOOST_ASIO_DISABLE_SERIAL_PORT)
-# endif // !defined(__SYMBIAN32__)
-#endif // defined(BOOST_ASIO_HAS_IOCP)
-       //   || !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+#if !defined(BOOST_ASIO_HAS_SERIAL_PORT)
+# if defined(BOOST_ASIO_HAS_IOCP) \
+  || !defined(BOOST_ASIO_WINDOWS) \
+  && !defined(BOOST_ASIO_WINDOWS_RUNTIME) \
+  && !defined(__CYGWIN__)
+#  if !defined(__SYMBIAN32__)
+#   if !defined(BOOST_ASIO_DISABLE_SERIAL_PORT)
+#    define BOOST_ASIO_HAS_SERIAL_PORT 1
+#   endif // !defined(BOOST_ASIO_DISABLE_SERIAL_PORT)
+#  endif // !defined(__SYMBIAN32__)
+# endif // defined(BOOST_ASIO_HAS_IOCP)
+        //   || !defined(BOOST_ASIO_WINDOWS)
+        //   && !defined(BOOST_ASIO_WINDOWS_RUNTIME)
+        //   && !defined(__CYGWIN__)
+#endif // !defined(BOOST_ASIO_HAS_SERIAL_PORT)
 
 // Windows: stream handles.
-#if !defined(BOOST_ASIO_DISABLE_WINDOWS_STREAM_HANDLE)
-# if defined(BOOST_ASIO_HAS_IOCP)
-#  define BOOST_ASIO_HAS_WINDOWS_STREAM_HANDLE 1
-# endif // defined(BOOST_ASIO_HAS_IOCP)
-#endif // !defined(BOOST_ASIO_DISABLE_WINDOWS_STREAM_HANDLE)
+#if !defined(BOOST_ASIO_HAS_WINDOWS_STREAM_HANDLE)
+# if !defined(BOOST_ASIO_DISABLE_WINDOWS_STREAM_HANDLE)
+#  if defined(BOOST_ASIO_HAS_IOCP)
+#   define BOOST_ASIO_HAS_WINDOWS_STREAM_HANDLE 1
+#  endif // defined(BOOST_ASIO_HAS_IOCP)
+# endif // !defined(BOOST_ASIO_DISABLE_WINDOWS_STREAM_HANDLE)
+#endif // !defined(BOOST_ASIO_HAS_WINDOWS_STREAM_HANDLE)
 
 // Windows: random access handles.
-#if !defined(BOOST_ASIO_DISABLE_WINDOWS_RANDOM_ACCESS_HANDLE)
-# if defined(BOOST_ASIO_HAS_IOCP)
-#  define BOOST_ASIO_HAS_WINDOWS_RANDOM_ACCESS_HANDLE 1
-# endif // defined(BOOST_ASIO_HAS_IOCP)
-#endif // !defined(BOOST_ASIO_DISABLE_WINDOWS_RANDOM_ACCESS_HANDLE)
+#if !defined(BOOST_ASIO_HAS_WINDOWS_RANDOM_ACCESS_HANDLE)
+# if !defined(BOOST_ASIO_DISABLE_WINDOWS_RANDOM_ACCESS_HANDLE)
+#  if defined(BOOST_ASIO_HAS_IOCP)
+#   define BOOST_ASIO_HAS_WINDOWS_RANDOM_ACCESS_HANDLE 1
+#  endif // defined(BOOST_ASIO_HAS_IOCP)
+# endif // !defined(BOOST_ASIO_DISABLE_WINDOWS_RANDOM_ACCESS_HANDLE)
+#endif // !defined(BOOST_ASIO_HAS_WINDOWS_RANDOM_ACCESS_HANDLE)
 
 // Windows: object handles.
-#if !defined(BOOST_ASIO_DISABLE_WINDOWS_OBJECT_HANDLE)
-# if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
-#  if !defined(UNDER_CE)
-#   define BOOST_ASIO_HAS_WINDOWS_OBJECT_HANDLE 1
-#  endif // !defined(UNDER_CE)
-# endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
-#endif // !defined(BOOST_ASIO_DISABLE_WINDOWS_OBJECT_HANDLE)
+#if !defined(BOOST_ASIO_HAS_WINDOWS_OBJECT_HANDLE)
+# if !defined(BOOST_ASIO_DISABLE_WINDOWS_OBJECT_HANDLE)
+#  if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
+#   if !defined(UNDER_CE)
+#    define BOOST_ASIO_HAS_WINDOWS_OBJECT_HANDLE 1
+#   endif // !defined(UNDER_CE)
+#  endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
+# endif // !defined(BOOST_ASIO_DISABLE_WINDOWS_OBJECT_HANDLE)
+#endif // !defined(BOOST_ASIO_HAS_WINDOWS_OBJECT_HANDLE)
 
 // Windows: OVERLAPPED wrapper.
-#if !defined(BOOST_ASIO_DISABLE_WINDOWS_OVERLAPPED_PTR)
-# if defined(BOOST_ASIO_HAS_IOCP)
-#  define BOOST_ASIO_HAS_WINDOWS_OVERLAPPED_PTR 1
-# endif // defined(BOOST_ASIO_HAS_IOCP)
-#endif // !defined(BOOST_ASIO_DISABLE_WINDOWS_OVERLAPPED_PTR)
+#if !defined(BOOST_ASIO_HAS_WINDOWS_OVERLAPPED_PTR)
+# if !defined(BOOST_ASIO_DISABLE_WINDOWS_OVERLAPPED_PTR)
+#  if defined(BOOST_ASIO_HAS_IOCP)
+#   define BOOST_ASIO_HAS_WINDOWS_OVERLAPPED_PTR 1
+#  endif // defined(BOOST_ASIO_HAS_IOCP)
+# endif // !defined(BOOST_ASIO_DISABLE_WINDOWS_OVERLAPPED_PTR)
+#endif // !defined(BOOST_ASIO_HAS_WINDOWS_OVERLAPPED_PTR)
 
 // POSIX: stream-oriented file descriptors.
-#if !defined(BOOST_ASIO_DISABLE_POSIX_STREAM_DESCRIPTOR)
-# if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
-#  define BOOST_ASIO_HAS_POSIX_STREAM_DESCRIPTOR 1
-# endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
-#endif // !defined(BOOST_ASIO_DISABLE_POSIX_STREAM_DESCRIPTOR)
+#if !defined(BOOST_ASIO_HAS_POSIX_STREAM_DESCRIPTOR)
+# if !defined(BOOST_ASIO_DISABLE_POSIX_STREAM_DESCRIPTOR)
+#  if !defined(BOOST_ASIO_WINDOWS) \
+  && !defined(BOOST_ASIO_WINDOWS_RUNTIME) \
+  && !defined(__CYGWIN__)
+#   define BOOST_ASIO_HAS_POSIX_STREAM_DESCRIPTOR 1
+#  endif // !defined(BOOST_ASIO_WINDOWS)
+         //   && !defined(BOOST_ASIO_WINDOWS_RUNTIME)
+         //   && !defined(__CYGWIN__)
+# endif // !defined(BOOST_ASIO_DISABLE_POSIX_STREAM_DESCRIPTOR)
+#endif // !defined(BOOST_ASIO_HAS_POSIX_STREAM_DESCRIPTOR)
 
 // UNIX domain sockets.
-#if !defined(BOOST_ASIO_DISABLE_LOCAL_SOCKETS)
-# if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
-#  define BOOST_ASIO_HAS_LOCAL_SOCKETS 1
-# endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
-#endif // !defined(BOOST_ASIO_DISABLE_LOCAL_SOCKETS)
+#if !defined(BOOST_ASIO_HAS_LOCAL_SOCKETS)
+# if !defined(BOOST_ASIO_DISABLE_LOCAL_SOCKETS)
+#  if !defined(BOOST_ASIO_WINDOWS) \
+  && !defined(BOOST_ASIO_WINDOWS_RUNTIME) \
+  && !defined(__CYGWIN__)
+#   define BOOST_ASIO_HAS_LOCAL_SOCKETS 1
+#  endif // !defined(BOOST_ASIO_WINDOWS)
+         //   && !defined(BOOST_ASIO_WINDOWS_RUNTIME)
+         //   && !defined(__CYGWIN__)
+# endif // !defined(BOOST_ASIO_DISABLE_LOCAL_SOCKETS)
+#endif // !defined(BOOST_ASIO_HAS_LOCAL_SOCKETS)
 
 // Can use sigaction() instead of signal().
-#if !defined(BOOST_ASIO_DISABLE_SIGACTION)
-# if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
-#  define BOOST_ASIO_HAS_SIGACTION 1
-# endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
-#endif // !defined(BOOST_ASIO_DISABLE_SIGACTION)
+#if !defined(BOOST_ASIO_HAS_SIGACTION)
+# if !defined(BOOST_ASIO_DISABLE_SIGACTION)
+#  if !defined(BOOST_ASIO_WINDOWS) \
+  && !defined(BOOST_ASIO_WINDOWS_RUNTIME) \
+  && !defined(__CYGWIN__)
+#   define BOOST_ASIO_HAS_SIGACTION 1
+#  endif // !defined(BOOST_ASIO_WINDOWS)
+         //   && !defined(BOOST_ASIO_WINDOWS_RUNTIME)
+         //   && !defined(__CYGWIN__)
+# endif // !defined(BOOST_ASIO_DISABLE_SIGACTION)
+#endif // !defined(BOOST_ASIO_HAS_SIGACTION)
 
 // Can use signal().
-#if !defined(BOOST_ASIO_DISABLE_SIGNAL)
-# if !defined(UNDER_CE)
-#  define BOOST_ASIO_HAS_SIGNAL 1
-# endif // !defined(UNDER_CE)
-#endif // !defined(BOOST_ASIO_DISABLE_SIGNAL)
+#if !defined(BOOST_ASIO_HAS_SIGNAL)
+# if !defined(BOOST_ASIO_DISABLE_SIGNAL)
+#  if !defined(UNDER_CE)
+#   define BOOST_ASIO_HAS_SIGNAL 1
+#  endif // !defined(UNDER_CE)
+# endif // !defined(BOOST_ASIO_DISABLE_SIGNAL)
+#endif // !defined(BOOST_ASIO_HAS_SIGNAL)
+
+// Can use getaddrinfo() and getnameinfo().
+#if !defined(BOOST_ASIO_HAS_GETADDRINFO)
+# if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
+#  if defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0501)
+#   define BOOST_ASIO_HAS_GETADDRINFO 1
+#  elif defined(UNDER_CE)
+#   define BOOST_ASIO_HAS_GETADDRINFO 1
+#  endif // defined(UNDER_CE)
+# elif !(defined(__MACH__) && defined(__APPLE__))
+#  define BOOST_ASIO_HAS_GETADDRINFO 1
+# endif // !(defined(__MACH__) && defined(__APPLE__))
+#endif // !defined(BOOST_ASIO_HAS_GETADDRINFO)
+
+// Whether standard iostreams are disabled.
+#if !defined(BOOST_ASIO_NO_IOSTREAM)
+# if defined(BOOST_ASIO_HAS_BOOST_CONFIG) && defined(BOOST_NO_IOSTREAM)
+#  define BOOST_ASIO_NO_IOSTREAM 1
+# endif // !defined(BOOST_NO_IOSTREAM)
+#endif // !defined(BOOST_ASIO_NO_IOSTREAM)
+
+// Whether exception handling is disabled.
+#if !defined(BOOST_ASIO_NO_EXCEPTIONS)
+# if defined(BOOST_ASIO_HAS_BOOST_CONFIG) && defined(BOOST_NO_EXCEPTIONS)
+#  define BOOST_ASIO_NO_EXCEPTIONS 1
+# endif // !defined(BOOST_NO_EXCEPTIONS)
+#endif // !defined(BOOST_ASIO_NO_EXCEPTIONS)
+
+// Whether the typeid operator is supported.
+#if !defined(BOOST_ASIO_NO_TYPEID)
+# if defined(BOOST_ASIO_HAS_BOOST_CONFIG) && defined(BOOST_NO_TYPEID)
+#  define BOOST_ASIO_NO_TYPEID 1
+# endif // !defined(BOOST_NO_TYPEID)
+#endif // !defined(BOOST_ASIO_NO_TYPEID)
+
+// On POSIX (and POSIX-like) platforms we need to include unistd.h in order to
+// get access to the various platform feature macros, e.g. to be able to test
+// for threads support.
+#if !defined(BOOST_ASIO_HAS_UNISTD_H)
+# if !defined(BOOST_ASIO_HAS_BOOST_CONFIG)
+#  if defined(unix) \
+   || defined(__unix) \
+   || defined(_XOPEN_SOURCE) \
+   || defined(_POSIX_SOURCE) \
+   || (defined(__MACH__) && defined(__APPLE__)) \
+   || defined(__FreeBSD__) \
+   || defined(__NetBSD__) \
+   || defined(__OpenBSD__) \
+   || defined(__linux__)
+#   define BOOST_ASIO_HAS_UNISTD_H 1
+#  endif
+# endif // !defined(BOOST_ASIO_HAS_BOOST_CONFIG)
+#endif // !defined(BOOST_ASIO_HAS_UNISTD_H)
+#if defined(BOOST_ASIO_HAS_UNISTD_H)
+# include <unistd.h>
+#endif // defined(BOOST_ASIO_HAS_UNISTD_H)
+
+// Threads.
+#if !defined(BOOST_ASIO_HAS_THREADS)
+# if !defined(BOOST_ASIO_DISABLE_THREADS)
+#  if defined(BOOST_ASIO_HAS_BOOST_CONFIG) && defined(BOOST_HAS_THREADS)
+#   define BOOST_ASIO_HAS_THREADS 1
+#  elif defined(_MSC_VER) && defined(_MT)
+#   define BOOST_ASIO_HAS_THREADS 1
+#  elif defined(__BORLANDC__) && defined(__MT__)
+#   define BOOST_ASIO_HAS_THREADS 1
+#  elif defined(_POSIX_THREADS)
+#   define BOOST_ASIO_HAS_THREADS 1
+#  endif // defined(BOOST_ASIO_HAS_BOOST_CONFIG) && defined(BOOST_HAS_THREADS)
+# endif // !defined(BOOST_ASIO_DISABLE_THREADS)
+#endif // !defined(BOOST_ASIO_HAS_THREADS)
+
+// POSIX threads.
+#if !defined(BOOST_ASIO_HAS_PTHREADS)
+# if defined(BOOST_ASIO_HAS_THREADS)
+#  if defined(BOOST_ASIO_HAS_BOOST_CONFIG) && defined(BOOST_HAS_PTHREADS)
+#   define BOOST_ASIO_HAS_PTHREADS 1
+#  elif defined(_POSIX_THREADS)
+#   define BOOST_ASIO_HAS_PTHREADS 1
+#  endif // defined(BOOST_ASIO_HAS_BOOST_CONFIG) && defined(BOOST_HAS_PTHREADS)
+# endif // defined(BOOST_ASIO_HAS_THREADS)
+#endif // !defined(BOOST_ASIO_HAS_PTHREADS)
+
+// Helper to prevent macro expansion.
+#define BOOST_ASIO_PREVENT_MACRO_SUBSTITUTION
+
+// Helper to define in-class constants.
+#if !defined(BOOST_ASIO_STATIC_CONSTANT)
+# if !defined(BOOST_ASIO_DISABLE_BOOST_STATIC_CONSTANT)
+#  define BOOST_ASIO_STATIC_CONSTANT(type, assignment) \
+    BOOST_STATIC_CONSTANT(type, assignment)
+# else // !defined(BOOST_ASIO_DISABLE_BOOST_STATIC_CONSTANT)
+#  define BOOST_ASIO_STATIC_CONSTANT(type, assignment) \
+    static const type assignment
+# endif // !defined(BOOST_ASIO_DISABLE_BOOST_STATIC_CONSTANT)
+#endif // !defined(BOOST_ASIO_STATIC_CONSTANT)
+
+// Boost array library.
+#if !defined(BOOST_ASIO_HAS_BOOST_ARRAY)
+# if !defined(BOOST_ASIO_DISABLE_BOOST_ARRAY)
+#  define BOOST_ASIO_HAS_BOOST_ARRAY 1
+# endif // !defined(BOOST_ASIO_DISABLE_BOOST_ARRAY)
+#endif // !defined(BOOST_ASIO_HAS_BOOST_ARRAY)
+
+// Boost assert macro.
+#if !defined(BOOST_ASIO_HAS_BOOST_ASSERT)
+# if !defined(BOOST_ASIO_DISABLE_BOOST_ASSERT)
+#  define BOOST_ASIO_HAS_BOOST_ASSERT 1
+# endif // !defined(BOOST_ASIO_DISABLE_BOOST_ASSERT)
+#endif // !defined(BOOST_ASIO_HAS_BOOST_ASSERT)
+
+// Boost limits header.
+#if !defined(BOOST_ASIO_HAS_BOOST_LIMITS)
+# if !defined(BOOST_ASIO_DISABLE_BOOST_LIMITS)
+#  define BOOST_ASIO_HAS_BOOST_LIMITS 1
+# endif // !defined(BOOST_ASIO_DISABLE_BOOST_LIMITS)
+#endif // !defined(BOOST_ASIO_HAS_BOOST_LIMITS)
+
+// Boost throw_exception function.
+#if !defined(BOOST_ASIO_HAS_BOOST_THROW_EXCEPTION)
+# if !defined(BOOST_ASIO_DISABLE_BOOST_THROW_EXCEPTION)
+#  define BOOST_ASIO_HAS_BOOST_THROW_EXCEPTION 1
+# endif // !defined(BOOST_ASIO_DISABLE_BOOST_THROW_EXCEPTION)
+#endif // !defined(BOOST_ASIO_HAS_BOOST_THROW_EXCEPTION)
+
+// Boost regex library.
+#if !defined(BOOST_ASIO_HAS_BOOST_REGEX)
+# if !defined(BOOST_ASIO_DISABLE_BOOST_REGEX)
+#  define BOOST_ASIO_HAS_BOOST_REGEX 1
+# endif // !defined(BOOST_ASIO_DISABLE_BOOST_REGEX)
+#endif // !defined(BOOST_ASIO_HAS_BOOST_REGEX)
+
+// Boost bind function.
+#if !defined(BOOST_ASIO_HAS_BOOST_BIND)
+# if !defined(BOOST_ASIO_DISABLE_BOOST_BIND)
+#  define BOOST_ASIO_HAS_BOOST_BIND 1
+# endif // !defined(BOOST_ASIO_DISABLE_BOOST_BIND)
+#endif // !defined(BOOST_ASIO_HAS_BOOST_BIND)
+
+// Boost's BOOST_WORKAROUND macro.
+#if !defined(BOOST_ASIO_HAS_BOOST_WORKAROUND)
+# if !defined(BOOST_ASIO_DISABLE_BOOST_WORKAROUND)
+#  define BOOST_ASIO_HAS_BOOST_WORKAROUND 1
+# endif // !defined(BOOST_ASIO_DISABLE_BOOST_WORKAROUND)
+#endif // !defined(BOOST_ASIO_HAS_BOOST_WORKAROUND)
+
+// Microsoft Visual C++'s secure C runtime library.
+#if !defined(BOOST_ASIO_HAS_SECURE_RTL)
+# if !defined(BOOST_ASIO_DISABLE_SECURE_RTL)
+#  if defined(BOOST_ASIO_MSVC) \
+    && (BOOST_ASIO_MSVC >= 1400) \
+    && !defined(UNDER_CE)
+#   define BOOST_ASIO_HAS_SECURE_RTL 1
+#  endif // defined(BOOST_ASIO_MSVC)
+         // && (BOOST_ASIO_MSVC >= 1400)
+         // && !defined(UNDER_CE)
+# endif // !defined(BOOST_ASIO_DISABLE_SECURE_RTL)
+#endif // !defined(BOOST_ASIO_HAS_SECURE_RTL)
+
+// Handler hooking. Disabled for ancient Borland C++ and gcc compilers.
+#if !defined(BOOST_ASIO_HAS_HANDLER_HOOKS)
+# if !defined(BOOST_ASIO_DISABLE_HANDLER_HOOKS)
+#  if defined(__GNUC__)
+#   if (__GNUC__ >= 3)
+#    define BOOST_ASIO_HAS_HANDLER_HOOKS 1
+#   endif // (__GNUC__ >= 3)
+#  elif !defined(__BORLANDC__)
+#   define BOOST_ASIO_HAS_HANDLER_HOOKS 1
+#  endif // !defined(__BORLANDC__)
+# endif // !defined(BOOST_ASIO_DISABLE_HANDLER_HOOKS)
+#endif // !defined(BOOST_ASIO_HAS_HANDLER_HOOKS)
 
 // Support for the __thread keyword extension.
 #if !defined(BOOST_ASIO_DISABLE_THREAD_KEYWORD_EXTENSION)
 # if defined(__linux__)
 #  if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
 #   if ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 3)
 #    if !defined(__INTEL_COMPILER) && !defined(__ICL)
 #     define BOOST_ASIO_HAS_THREAD_KEYWORD_EXTENSION 1
+#     define BOOST_ASIO_THREAD_KEYWORD __thread
 #    elif defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 1100)
 #     define BOOST_ASIO_HAS_THREAD_KEYWORD_EXTENSION 1
 #    endif // defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 1100)
 #   endif // ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 3)
 #  endif // defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
 # endif // defined(__linux__)
+# if defined(BOOST_ASIO_MSVC) && defined(BOOST_ASIO_WINDOWS_RUNTIME)
+#  if (_MSC_VER >= 1700)
+#   define BOOST_ASIO_HAS_THREAD_KEYWORD_EXTENSION 1
+#   define BOOST_ASIO_THREAD_KEYWORD __declspec(thread)
+#  endif // (_MSC_VER >= 1700)
+# endif // defined(BOOST_ASIO_MSVC) && defined(BOOST_ASIO_WINDOWS_RUNTIME)
 #endif // !defined(BOOST_ASIO_DISABLE_THREAD_KEYWORD_EXTENSION)
+#if !defined(BOOST_ASIO_THREAD_KEYWORD)
+# define BOOST_ASIO_THREAD_KEYWORD __thread
+#endif // !defined(BOOST_ASIO_THREAD_KEYWORD)
+
+// Support for POSIX ssize_t typedef.
+#if !defined(BOOST_ASIO_DISABLE_SSIZE_T)
+# if defined(__linux__) \
+   || (defined(__MACH__) && defined(__APPLE__))
+#  define BOOST_ASIO_HAS_SSIZE_T 1
+# endif // defined(__linux__)
+        //   || (defined(__MACH__) && defined(__APPLE__))
+#endif // !defined(BOOST_ASIO_DISABLE_SSIZE_T)
 
 #endif // BOOST_ASIO_DETAIL_CONFIG_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/consuming_buffers.hpp b/3rdParty/Boost/src/boost/asio/detail/consuming_buffers.hpp
index e13403f..8bd36e4 100644
--- a/3rdParty/Boost/src/boost/asio/detail/consuming_buffers.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/consuming_buffers.hpp
@@ -1,11 +1,11 @@
 //
 // detail/consuming_buffers.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_CONSUMING_BUFFERS_HPP
@@ -14,28 +14,42 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 #include <cstddef>
-#include <boost/iterator.hpp>
-#include <boost/limits.hpp>
+#include <iterator>
 #include <boost/asio/buffer.hpp>
+#include <boost/asio/detail/limits.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 // A proxy iterator for a sub-range in a list of buffers.
 template <typename Buffer, typename Buffer_Iterator>
 class consuming_buffers_iterator
-  : public boost::iterator<std::forward_iterator_tag, const Buffer>
 {
 public:
+  /// The type used for the distance between two iterators.
+  typedef std::ptrdiff_t difference_type;
+
+  /// The type of the value pointed to by the iterator.
+  typedef Buffer value_type;
+
+  /// The type of the result of applying operator->() to the iterator.
+  typedef const Buffer* pointer;
+
+  /// The type of the result of applying operator*() to the iterator.
+  typedef const Buffer& reference;
+
+  /// The iterator category.
+  typedef std::forward_iterator_tag iterator_category;
+
   // Default constructor creates an end iterator.
   consuming_buffers_iterator()
     : at_end_(true)
   {
   }
 
diff --git a/3rdParty/Boost/src/boost/asio/detail/cstdint.hpp b/3rdParty/Boost/src/boost/asio/detail/cstdint.hpp
new file mode 100644
index 0000000..ad611e9
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/detail/cstdint.hpp
@@ -0,0 +1,48 @@
+//
+// detail/cstdint.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_DETAIL_CSTDINT_HPP
+#define BOOST_ASIO_DETAIL_CSTDINT_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HAS_CSTDINT)
+# include <cstdint>
+#else // defined(BOOST_ASIO_HAS_CSTDINT)
+# include <boost/cstdint.hpp>
+#endif // defined(BOOST_ASIO_HAS_CSTDINT)
+
+namespace boost {
+namespace asio {
+
+#if defined(BOOST_ASIO_HAS_CSTDINT)
+using std::int16_t;
+using std::uint16_t;
+using std::int32_t;
+using std::uint32_t;
+using std::int64_t;
+using std::uint64_t;
+#else // defined(BOOST_ASIO_HAS_CSTDINT)
+using boost::int16_t;
+using boost::uint16_t;
+using boost::int32_t;
+using boost::uint32_t;
+using boost::int64_t;
+using boost::uint64_t;
+#endif // defined(BOOST_ASIO_HAS_CSTDINT)
+
+} // namespace asio
+} // namespace boost
+
+#endif // BOOST_ASIO_DETAIL_CSTDINT_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/date_time_fwd.hpp b/3rdParty/Boost/src/boost/asio/detail/date_time_fwd.hpp
index 162ccdc..1c0bcaf 100644
--- a/3rdParty/Boost/src/boost/asio/detail/date_time_fwd.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/date_time_fwd.hpp
@@ -1,11 +1,11 @@
 //
 // detail/date_time_fwd.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_DATE_TIME_FWD_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/deadline_timer_service.hpp b/3rdParty/Boost/src/boost/asio/detail/deadline_timer_service.hpp
index 833815a..52e2639 100644
--- a/3rdParty/Boost/src/boost/asio/detail/deadline_timer_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/deadline_timer_service.hpp
@@ -1,11 +1,11 @@
 //
 // detail/deadline_timer_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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_DEADLINE_TIMER_SERVICE_HPP
@@ -16,22 +16,28 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 #include <cstddef>
 #include <boost/asio/error.hpp>
 #include <boost/asio/io_service.hpp>
+#include <boost/asio/detail/addressof.hpp>
 #include <boost/asio/detail/bind_handler.hpp>
 #include <boost/asio/detail/fenced_block.hpp>
 #include <boost/asio/detail/noncopyable.hpp>
 #include <boost/asio/detail/socket_ops.hpp>
 #include <boost/asio/detail/socket_types.hpp>
 #include <boost/asio/detail/timer_queue.hpp>
 #include <boost/asio/detail/timer_scheduler.hpp>
 #include <boost/asio/detail/wait_handler.hpp>
 #include <boost/asio/detail/wait_op.hpp>
 
+#if defined(BOOST_ASIO_WINDOWS_RUNTIME)
+# include <chrono>
+# include <thread>
+#endif // defined(BOOST_ASIO_WINDOWS_RUNTIME)
+
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
@@ -167,17 +173,17 @@ public:
       now = Time_Traits::now();
     }
   }
 
   // Start an asynchronous wait on the timer.
   template <typename Handler>
-  void async_wait(implementation_type& impl, Handler handler)
+  void async_wait(implementation_type& impl, Handler& handler)
   {
     // Allocate and construct an operation to wrap the handler.
     typedef wait_handler<Handler> op;
-    typename op::ptr p = { boost::addressof(handler),
+    typename op::ptr p = { boost::asio::detail::addressof(handler),
       boost_asio_handler_alloc_helpers::allocate(
         sizeof(op), handler), 0 };
     p.p = new (p.v) op(handler);
 
     impl.might_have_pending_waits = true;
 
@@ -191,16 +197,23 @@ private:
   // Helper function to wait given a duration type. The duration type should
   // either be of type boost::posix_time::time_duration, or implement the
   // required subset of its interface.
   template <typename Duration>
   void do_wait(const Duration& timeout, boost::system::error_code& ec)
   {
+#if defined(BOOST_ASIO_WINDOWS_RUNTIME)
+    std::this_thread::sleep_for(
+        std::chrono::seconds(timeout.total_seconds())
+        + std::chrono::microseconds(timeout.total_microseconds()));
+    ec = boost::system::error_code();
+#else // defined(BOOST_ASIO_WINDOWS_RUNTIME)
     ::timeval tv;
     tv.tv_sec = timeout.total_seconds();
     tv.tv_usec = timeout.total_microseconds() % 1000000;
     socket_ops::select(0, 0, 0, 0, &tv, ec);
+#endif // defined(BOOST_ASIO_WINDOWS_RUNTIME)
   }
 
   // The queue of timers.
   timer_queue<Time_Traits> timer_queue_;
 
   // The object that schedules and executes timers. Usually a reactor.
diff --git a/3rdParty/Boost/src/boost/asio/detail/dependent_type.hpp b/3rdParty/Boost/src/boost/asio/detail/dependent_type.hpp
index c7b1c1b..a9e7fed 100644
--- a/3rdParty/Boost/src/boost/asio/detail/dependent_type.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/dependent_type.hpp
@@ -1,11 +1,11 @@
 //
 // detail/dependent_type.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_DEPENDENT_TYPE_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/descriptor_ops.hpp b/3rdParty/Boost/src/boost/asio/detail/descriptor_ops.hpp
index 72ea6e2..b9fbadc 100644
--- a/3rdParty/Boost/src/boost/asio/detail/descriptor_ops.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/descriptor_ops.hpp
@@ -1,11 +1,11 @@
 //
 // detail/descriptor_ops.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_DESCRIPTOR_OPS_HPP
@@ -14,13 +14,15 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
-#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+#if !defined(BOOST_ASIO_WINDOWS) \
+  && !defined(BOOST_ASIO_WINDOWS_RUNTIME) \
+  && !defined(__CYGWIN__)
 
 #include <cstddef>
 #include <boost/system/error_code.hpp>
 #include <boost/asio/detail/socket_types.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
@@ -85,15 +87,15 @@ BOOST_ASIO_DECL bool non_blocking_write(int d,
     const buf* bufs, std::size_t count,
     boost::system::error_code& ec, std::size_t& bytes_transferred);
 
 BOOST_ASIO_DECL int ioctl(int d, state_type& state, long cmd,
     ioctl_arg_type* arg, boost::system::error_code& ec);
 
-BOOST_ASIO_DECL int fcntl(int d, long cmd, boost::system::error_code& ec);
+BOOST_ASIO_DECL int fcntl(int d, int cmd, boost::system::error_code& ec);
 
-BOOST_ASIO_DECL int fcntl(int d, long cmd,
+BOOST_ASIO_DECL int fcntl(int d, int cmd,
     long arg, boost::system::error_code& ec);
 
 BOOST_ASIO_DECL int poll_read(int d,
     state_type state, boost::system::error_code& ec);
 
 BOOST_ASIO_DECL int poll_write(int d,
@@ -107,9 +109,11 @@ BOOST_ASIO_DECL int poll_write(int d,
 #include <boost/asio/detail/pop_options.hpp>
 
 #if defined(BOOST_ASIO_HEADER_ONLY)
 # include <boost/asio/detail/impl/descriptor_ops.ipp>
 #endif // defined(BOOST_ASIO_HEADER_ONLY)
 
-#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+#endif // !defined(BOOST_ASIO_WINDOWS)
+       //   && !defined(BOOST_ASIO_WINDOWS_RUNTIME)
+       //   && !defined(__CYGWIN__)
 
 #endif // BOOST_ASIO_DETAIL_DESCRIPTOR_OPS_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/descriptor_read_op.hpp b/3rdParty/Boost/src/boost/asio/detail/descriptor_read_op.hpp
index 9f4adff..6993bd6 100644
--- a/3rdParty/Boost/src/boost/asio/detail/descriptor_read_op.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/descriptor_read_op.hpp
@@ -1,11 +1,11 @@
 //
 // detail/descriptor_read_op.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_DESCRIPTOR_READ_OP_HPP
@@ -14,15 +14,15 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
-#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+#if !defined(BOOST_ASIO_WINDOWS) && !defined(__CYGWIN__)
 
-#include <boost/utility/addressof.hpp>
+#include <boost/asio/detail/addressof.hpp>
 #include <boost/asio/detail/bind_handler.hpp>
 #include <boost/asio/detail/buffer_sequence_adapter.hpp>
 #include <boost/asio/detail/descriptor_ops.hpp>
 #include <boost/asio/detail/fenced_block.hpp>
 #include <boost/asio/detail/reactor_op.hpp>
 
@@ -78,25 +78,25 @@ public:
   static void do_complete(io_service_impl* owner, operation* base,
       const boost::system::error_code& /*ec*/,
       std::size_t /*bytes_transferred*/)
   {
     // Take ownership of the handler object.
     descriptor_read_op* o(static_cast<descriptor_read_op*>(base));
-    ptr p = { boost::addressof(o->handler_), o, o };
+    ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
 
     BOOST_ASIO_HANDLER_COMPLETION((o));
 
     // Make a copy of the handler so that the memory can be deallocated before
     // the upcall is made. Even if we're not about to make an upcall, a
     // sub-object of the handler may be the true owner of the memory associated
     // with the handler. Consequently, a local copy of the handler is required
     // to ensure that any owning sub-object remains valid until after we have
     // deallocated the memory here.
     detail::binder2<Handler, boost::system::error_code, std::size_t>
       handler(o->handler_, o->ec_, o->bytes_transferred_);
-    p.h = boost::addressof(handler.handler_);
+    p.h = boost::asio::detail::addressof(handler.handler_);
     p.reset();
 
     // Make the upcall if required.
     if (owner)
     {
       fenced_block b(fenced_block::half);
@@ -113,9 +113,9 @@ private:
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
-#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+#endif // !defined(BOOST_ASIO_WINDOWS) && !defined(__CYGWIN__)
 
 #endif // BOOST_ASIO_DETAIL_DESCRIPTOR_READ_OP_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/descriptor_write_op.hpp b/3rdParty/Boost/src/boost/asio/detail/descriptor_write_op.hpp
index 88c80c8..ec83eef 100644
--- a/3rdParty/Boost/src/boost/asio/detail/descriptor_write_op.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/descriptor_write_op.hpp
@@ -1,11 +1,11 @@
 //
 // detail/descriptor_write_op.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_DESCRIPTOR_WRITE_OP_HPP
@@ -14,15 +14,15 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
-#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+#if !defined(BOOST_ASIO_WINDOWS) && !defined(__CYGWIN__)
 
-#include <boost/utility/addressof.hpp>
+#include <boost/asio/detail/addressof.hpp>
 #include <boost/asio/detail/bind_handler.hpp>
 #include <boost/asio/detail/buffer_sequence_adapter.hpp>
 #include <boost/asio/detail/descriptor_ops.hpp>
 #include <boost/asio/detail/fenced_block.hpp>
 #include <boost/asio/detail/reactor_op.hpp>
 
@@ -78,25 +78,25 @@ public:
   static void do_complete(io_service_impl* owner, operation* base,
       const boost::system::error_code& /*ec*/,
       std::size_t /*bytes_transferred*/)
   {
     // Take ownership of the handler object.
     descriptor_write_op* o(static_cast<descriptor_write_op*>(base));
-    ptr p = { boost::addressof(o->handler_), o, o };
+    ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
 
     BOOST_ASIO_HANDLER_COMPLETION((o));
 
     // Make a copy of the handler so that the memory can be deallocated before
     // the upcall is made. Even if we're not about to make an upcall, a
     // sub-object of the handler may be the true owner of the memory associated
     // with the handler. Consequently, a local copy of the handler is required
     // to ensure that any owning sub-object remains valid until after we have
     // deallocated the memory here.
     detail::binder2<Handler, boost::system::error_code, std::size_t>
       handler(o->handler_, o->ec_, o->bytes_transferred_);
-    p.h = boost::addressof(handler.handler_);
+    p.h = boost::asio::detail::addressof(handler.handler_);
     p.reset();
 
     // Make the upcall if required.
     if (owner)
     {
       fenced_block b(fenced_block::half);
@@ -113,9 +113,9 @@ private:
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
-#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+#endif // !defined(BOOST_ASIO_WINDOWS) && !defined(__CYGWIN__)
 
 #endif // BOOST_ASIO_DETAIL_DESCRIPTOR_WRITE_OP_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/dev_poll_reactor.hpp b/3rdParty/Boost/src/boost/asio/detail/dev_poll_reactor.hpp
index e6b6e12..379e390 100644
--- a/3rdParty/Boost/src/boost/asio/detail/dev_poll_reactor.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/dev_poll_reactor.hpp
@@ -1,11 +1,11 @@
 //
 // detail/dev_poll_reactor.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_DEV_POLL_REACTOR_HPP
@@ -16,26 +16,24 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
 #if defined(BOOST_ASIO_HAS_DEV_POLL)
 
-#include <boost/limits.hpp>
 #include <cstddef>
 #include <vector>
 #include <sys/devpoll.h>
-#include <boost/asio/detail/dev_poll_reactor_fwd.hpp>
 #include <boost/asio/detail/hash_map.hpp>
+#include <boost/asio/detail/limits.hpp>
 #include <boost/asio/detail/mutex.hpp>
 #include <boost/asio/detail/op_queue.hpp>
 #include <boost/asio/detail/reactor_op.hpp>
 #include <boost/asio/detail/reactor_op_queue.hpp>
 #include <boost/asio/detail/select_interrupter.hpp>
 #include <boost/asio/detail/socket_types.hpp>
 #include <boost/asio/detail/timer_queue_base.hpp>
-#include <boost/asio/detail/timer_queue_fwd.hpp>
 #include <boost/asio/detail/timer_queue_set.hpp>
 #include <boost/asio/detail/wait_op.hpp>
 #include <boost/asio/io_service.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
@@ -84,21 +82,22 @@ public:
   // Move descriptor registration from one descriptor_data object to another.
   BOOST_ASIO_DECL void move_descriptor(socket_type descriptor,
       per_descriptor_data& target_descriptor_data,
       per_descriptor_data& source_descriptor_data);
 
   // Post a reactor operation for immediate completion.
-  void post_immediate_completion(reactor_op* op)
+  void post_immediate_completion(reactor_op* op, bool is_continuation)
   {
-    io_service_.post_immediate_completion(op);
+    io_service_.post_immediate_completion(op, is_continuation);
   }
 
   // Start a new operation. The reactor operation will be performed when the
   // given descriptor is flagged as ready, or an error has occurred.
   BOOST_ASIO_DECL void start_op(int op_type, socket_type descriptor,
-      per_descriptor_data&, reactor_op* op, bool allow_speculative);
+      per_descriptor_data&, reactor_op* op,
+      bool is_continuation, bool allow_speculative);
 
   // Cancel all operations associated with the given descriptor. The
   // handlers associated with the descriptor will be invoked with the
   // operation_aborted error.
   BOOST_ASIO_DECL void cancel_ops(socket_type descriptor, per_descriptor_data&);
 
diff --git a/3rdParty/Boost/src/boost/asio/detail/dev_poll_reactor_fwd.hpp b/3rdParty/Boost/src/boost/asio/detail/dev_poll_reactor_fwd.hpp
deleted file mode 100644
index 026f91a..0000000
--- a/3rdParty/Boost/src/boost/asio/detail/dev_poll_reactor_fwd.hpp
+++ /dev/null
@@ -1,34 +0,0 @@
-//
-// detail/dev_poll_reactor_fwd.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2012 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_DETAIL_DEV_POLL_REACTOR_FWD_HPP
-#define BOOST_ASIO_DETAIL_DEV_POLL_REACTOR_FWD_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include <boost/asio/detail/config.hpp>
-
-#if defined(BOOST_ASIO_HAS_DEV_POLL)
-
-namespace boost {
-namespace asio {
-namespace detail {
-
-class dev_poll_reactor;
-
-} // namespace detail
-} // namespace asio
-} // namespace boost
-
-#endif // defined(BOOST_ASIO_HAS_DEV_POLL)
-
-#endif // BOOST_ASIO_DETAIL_DEV_POLL_REACTOR_FWD_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/epoll_reactor.hpp b/3rdParty/Boost/src/boost/asio/detail/epoll_reactor.hpp
index 8f66f74..976da8a 100644
--- a/3rdParty/Boost/src/boost/asio/detail/epoll_reactor.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/epoll_reactor.hpp
@@ -1,11 +1,11 @@
 //
 // detail/epoll_reactor.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_EPOLL_REACTOR_HPP
@@ -16,25 +16,22 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
 #if defined(BOOST_ASIO_HAS_EPOLL)
 
-#include <boost/cstdint.hpp>
-#include <boost/limits.hpp>
 #include <boost/asio/io_service.hpp>
 #include <boost/asio/detail/atomic_count.hpp>
-#include <boost/asio/detail/epoll_reactor_fwd.hpp>
+#include <boost/asio/detail/limits.hpp>
 #include <boost/asio/detail/mutex.hpp>
 #include <boost/asio/detail/object_pool.hpp>
 #include <boost/asio/detail/op_queue.hpp>
 #include <boost/asio/detail/reactor_op.hpp>
 #include <boost/asio/detail/select_interrupter.hpp>
 #include <boost/asio/detail/socket_types.hpp>
 #include <boost/asio/detail/timer_queue_base.hpp>
-#include <boost/asio/detail/timer_queue_fwd.hpp>
 #include <boost/asio/detail/timer_queue_set.hpp>
 #include <boost/asio/detail/wait_op.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
@@ -57,13 +54,13 @@ public:
     descriptor_state* next_;
     descriptor_state* prev_;
 
     mutex mutex_;
     epoll_reactor* reactor_;
     int descriptor_;
-    boost::uint32_t registered_events_;
+    uint32_t registered_events_;
     op_queue<reactor_op> op_queue_[max_ops];
     bool shutdown_;
 
     BOOST_ASIO_DECL descriptor_state();
     void set_ready_events(uint32_t events) { task_result_ = events; }
     BOOST_ASIO_DECL operation* perform_io(uint32_t events);
@@ -105,22 +102,22 @@ public:
   // Move descriptor registration from one descriptor_data object to another.
   BOOST_ASIO_DECL void move_descriptor(socket_type descriptor,
       per_descriptor_data& target_descriptor_data,
       per_descriptor_data& source_descriptor_data);
 
   // Post a reactor operation for immediate completion.
-  void post_immediate_completion(reactor_op* op)
+  void post_immediate_completion(reactor_op* op, bool is_continuation)
   {
-    io_service_.post_immediate_completion(op);
+    io_service_.post_immediate_completion(op, is_continuation);
   }
 
   // Start a new operation. The reactor operation will be performed when the
   // given descriptor is flagged as ready, or an error has occurred.
   BOOST_ASIO_DECL void start_op(int op_type, socket_type descriptor,
       per_descriptor_data& descriptor_data, reactor_op* op,
-      bool allow_speculative);
+      bool is_continuation, bool allow_speculative);
 
   // Cancel all operations associated with the given descriptor. The
   // handlers associated with the descriptor will be invoked with the
   // operation_aborted error.
   BOOST_ASIO_DECL void cancel_ops(socket_type descriptor,
       per_descriptor_data& descriptor_data);
diff --git a/3rdParty/Boost/src/boost/asio/detail/epoll_reactor_fwd.hpp b/3rdParty/Boost/src/boost/asio/detail/epoll_reactor_fwd.hpp
deleted file mode 100644
index aa28271..0000000
--- a/3rdParty/Boost/src/boost/asio/detail/epoll_reactor_fwd.hpp
+++ /dev/null
@@ -1,34 +0,0 @@
-//
-// detail/epoll_reactor_fwd.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2012 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_DETAIL_EPOLL_REACTOR_FWD_HPP
-#define BOOST_ASIO_DETAIL_EPOLL_REACTOR_FWD_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include <boost/asio/detail/config.hpp>
-
-#if defined(BOOST_ASIO_HAS_EPOLL)
-
-namespace boost {
-namespace asio {
-namespace detail {
-
-class epoll_reactor;
-
-} // namespace detail
-} // namespace asio
-} // namespace boost
-
-#endif // defined(BOOST_ASIO_HAS_EPOLL)
-
-#endif // BOOST_ASIO_DETAIL_EPOLL_REACTOR_FWD_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/event.hpp b/3rdParty/Boost/src/boost/asio/detail/event.hpp
index 0ee6b6e..a18affe 100644
--- a/3rdParty/Boost/src/boost/asio/detail/event.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/event.hpp
@@ -1,11 +1,11 @@
 //
 // detail/event.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_EVENT_HPP
@@ -14,32 +14,36 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
-#if !defined(BOOST_HAS_THREADS) || defined(BOOST_ASIO_DISABLE_THREADS)
+#if !defined(BOOST_ASIO_HAS_THREADS)
 # include <boost/asio/detail/null_event.hpp>
-#elif defined(BOOST_WINDOWS)
+#elif defined(BOOST_ASIO_WINDOWS)
 # include <boost/asio/detail/win_event.hpp>
-#elif defined(BOOST_HAS_PTHREADS)
+#elif defined(BOOST_ASIO_HAS_PTHREADS)
 # include <boost/asio/detail/posix_event.hpp>
+#elif defined(BOOST_ASIO_HAS_STD_MUTEX_AND_CONDVAR)
+# include <boost/asio/detail/std_event.hpp>
 #else
-# error Only Windows and POSIX are supported!
+# error Only Windows, POSIX and std::condition_variable are supported!
 #endif
 
 namespace boost {
 namespace asio {
 namespace detail {
 
-#if !defined(BOOST_HAS_THREADS) || defined(BOOST_ASIO_DISABLE_THREADS)
+#if !defined(BOOST_ASIO_HAS_THREADS)
 typedef null_event event;
-#elif defined(BOOST_WINDOWS)
+#elif defined(BOOST_ASIO_WINDOWS)
 typedef win_event event;
-#elif defined(BOOST_HAS_PTHREADS)
+#elif defined(BOOST_ASIO_HAS_PTHREADS)
 typedef posix_event event;
+#elif defined(BOOST_ASIO_HAS_STD_MUTEX_AND_CONDVAR)
+typedef std_event event;
 #endif
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
diff --git a/3rdParty/Boost/src/boost/asio/detail/eventfd_select_interrupter.hpp b/3rdParty/Boost/src/boost/asio/detail/eventfd_select_interrupter.hpp
index cf40eee..7012372 100644
--- a/3rdParty/Boost/src/boost/asio/detail/eventfd_select_interrupter.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/eventfd_select_interrupter.hpp
@@ -1,11 +1,11 @@
 //
 // detail/eventfd_select_interrupter.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 Roelof Naude (roelof.naude at gmail 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)
 //
 
diff --git a/3rdParty/Boost/src/boost/asio/detail/fd_set_adapter.hpp b/3rdParty/Boost/src/boost/asio/detail/fd_set_adapter.hpp
index 51fe927..7aebdef 100644
--- a/3rdParty/Boost/src/boost/asio/detail/fd_set_adapter.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/fd_set_adapter.hpp
@@ -1,11 +1,11 @@
 //
 // detail/fd_set_adapter.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_FD_SET_ADAPTER_HPP
@@ -13,24 +13,29 @@
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
+
+#if !defined(BOOST_ASIO_WINDOWS_RUNTIME)
+
 #include <boost/asio/detail/posix_fd_set_adapter.hpp>
 #include <boost/asio/detail/win_fd_set_adapter.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 typedef win_fd_set_adapter fd_set_adapter;
 #else
 typedef posix_fd_set_adapter fd_set_adapter;
 #endif
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
+#endif // !defined(BOOST_ASIO_WINDOWS_RUNTIME)
+
 #endif // BOOST_ASIO_DETAIL_FD_SET_ADAPTER_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/fenced_block.hpp b/3rdParty/Boost/src/boost/asio/detail/fenced_block.hpp
index d9e8a04..1ee26cf 100644
--- a/3rdParty/Boost/src/boost/asio/detail/fenced_block.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/fenced_block.hpp
@@ -1,11 +1,11 @@
 //
 // detail/fenced_block.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_FENCED_BLOCK_HPP
@@ -14,14 +14,13 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
-#if !defined(BOOST_HAS_THREADS) \
-  || defined(BOOST_ASIO_DISABLE_THREADS) \
+#if !defined(BOOST_ASIO_HAS_THREADS) \
   || defined(BOOST_ASIO_DISABLE_FENCED_BLOCK)
 # include <boost/asio/detail/null_fenced_block.hpp>
 #elif defined(__MACH__) && defined(__APPLE__)
 # include <boost/asio/detail/macos_fenced_block.hpp>
 #elif defined(__sun)
 # include <boost/asio/detail/solaris_fenced_block.hpp>
@@ -34,24 +33,23 @@
 # include <boost/asio/detail/gcc_x86_fenced_block.hpp>
 #elif defined(__GNUC__) \
   && ((__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4)) \
   && !defined(__INTEL_COMPILER) && !defined(__ICL) \
   && !defined(__ICC) && !defined(__ECC) && !defined(__PATHSCALE__)
 # include <boost/asio/detail/gcc_sync_fenced_block.hpp>
-#elif defined(BOOST_WINDOWS) && !defined(UNDER_CE)
+#elif defined(BOOST_ASIO_WINDOWS) && !defined(UNDER_CE)
 # include <boost/asio/detail/win_fenced_block.hpp>
 #else
 # include <boost/asio/detail/null_fenced_block.hpp>
 #endif
 
 namespace boost {
 namespace asio {
 namespace detail {
 
-#if !defined(BOOST_HAS_THREADS) \
-  || defined(BOOST_ASIO_DISABLE_THREADS) \
+#if !defined(BOOST_ASIO_HAS_THREADS) \
   || defined(BOOST_ASIO_DISABLE_FENCED_BLOCK)
 typedef null_fenced_block fenced_block;
 #elif defined(__MACH__) && defined(__APPLE__)
 typedef macos_fenced_block fenced_block;
 #elif defined(__sun)
 typedef solaris_fenced_block fenced_block;
@@ -64,13 +62,13 @@ typedef gcc_hppa_fenced_block fenced_block;
 typedef gcc_x86_fenced_block fenced_block;
 #elif defined(__GNUC__) \
   && ((__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4)) \
   && !defined(__INTEL_COMPILER) && !defined(__ICL) \
   && !defined(__ICC) && !defined(__ECC) && !defined(__PATHSCALE__)
 typedef gcc_sync_fenced_block fenced_block;
-#elif defined(BOOST_WINDOWS) && !defined(UNDER_CE)
+#elif defined(BOOST_ASIO_WINDOWS) && !defined(UNDER_CE)
 typedef win_fenced_block fenced_block;
 #else
 typedef null_fenced_block fenced_block;
 #endif
 
 } // namespace detail
diff --git a/3rdParty/Boost/src/boost/asio/detail/function.hpp b/3rdParty/Boost/src/boost/asio/detail/function.hpp
new file mode 100644
index 0000000..1edcb1b
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/detail/function.hpp
@@ -0,0 +1,40 @@
+//
+// detail/function.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_DETAIL_FUNCTION_HPP
+#define BOOST_ASIO_DETAIL_FUNCTION_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HAS_STD_FUNCTION)
+# include <functional>
+#else // defined(BOOST_ASIO_HAS_STD_FUNCTION)
+# include <boost/function.hpp>
+#endif // defined(BOOST_ASIO_HAS_STD_FUNCTION)
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+#if defined(BOOST_ASIO_HAS_STD_FUNCTION)
+using std::function;
+#else // defined(BOOST_ASIO_HAS_STD_FUNCTION)
+using boost::function;
+#endif // defined(BOOST_ASIO_HAS_STD_FUNCTION)
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#endif // BOOST_ASIO_DETAIL_FUNCTION_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/gcc_arm_fenced_block.hpp b/3rdParty/Boost/src/boost/asio/detail/gcc_arm_fenced_block.hpp
index 1b3c764..5d5fc5c 100644
--- a/3rdParty/Boost/src/boost/asio/detail/gcc_arm_fenced_block.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/gcc_arm_fenced_block.hpp
@@ -1,11 +1,11 @@
 //
 // detail/gcc_arm_fenced_block.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_GCC_ARM_FENCED_BLOCK_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/gcc_hppa_fenced_block.hpp b/3rdParty/Boost/src/boost/asio/detail/gcc_hppa_fenced_block.hpp
index 421d3a6..61ad438 100644
--- a/3rdParty/Boost/src/boost/asio/detail/gcc_hppa_fenced_block.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/gcc_hppa_fenced_block.hpp
@@ -1,11 +1,11 @@
 //
 // detail/gcc_hppa_fenced_block.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_GCC_HPPA_FENCED_BLOCK_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/gcc_sync_fenced_block.hpp b/3rdParty/Boost/src/boost/asio/detail/gcc_sync_fenced_block.hpp
index 81aaeb0..226cfa7 100644
--- a/3rdParty/Boost/src/boost/asio/detail/gcc_sync_fenced_block.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/gcc_sync_fenced_block.hpp
@@ -1,11 +1,11 @@
 //
 // detail/gcc_sync_fenced_block.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_GCC_SYNC_FENCED_BLOCK_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/gcc_x86_fenced_block.hpp b/3rdParty/Boost/src/boost/asio/detail/gcc_x86_fenced_block.hpp
index 973165a..d39c693 100644
--- a/3rdParty/Boost/src/boost/asio/detail/gcc_x86_fenced_block.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/gcc_x86_fenced_block.hpp
@@ -1,11 +1,11 @@
 //
 // detail/gcc_x86_fenced_block.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_GCC_X86_FENCED_BLOCK_HPP
@@ -61,22 +61,30 @@ private:
     return r;
   }
 
   static void lbarrier()
   {
 #if defined(__SSE2__)
+# if (__GNUC__ >= 4) && !defined(__INTEL_COMPILER) && !defined(__ICL)
+    __builtin_ia32_lfence();
+# else // (__GNUC__ >= 4) && !defined(__INTEL_COMPILER) && !defined(__ICL)
     __asm__ __volatile__ ("lfence" ::: "memory");
+# endif // (__GNUC__ >= 4) && !defined(__INTEL_COMPILER) && !defined(__ICL)
 #else // defined(__SSE2__)
     barrier();
 #endif // defined(__SSE2__)
   }
 
   static void sbarrier()
   {
 #if defined(__SSE2__)
+# if (__GNUC__ >= 4) && !defined(__INTEL_COMPILER) && !defined(__ICL)
+    __builtin_ia32_sfence();
+# else // (__GNUC__ >= 4) && !defined(__INTEL_COMPILER) && !defined(__ICL)
     __asm__ __volatile__ ("sfence" ::: "memory");
+# endif // (__GNUC__ >= 4) && !defined(__INTEL_COMPILER) && !defined(__ICL)
 #else // defined(__SSE2__)
     barrier();
 #endif // defined(__SSE2__)
   }
 };
 
diff --git a/3rdParty/Boost/src/boost/asio/detail/handler_alloc_helpers.hpp b/3rdParty/Boost/src/boost/asio/detail/handler_alloc_helpers.hpp
index 91e993c..dac3737 100644
--- a/3rdParty/Boost/src/boost/asio/detail/handler_alloc_helpers.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/handler_alloc_helpers.hpp
@@ -1,11 +1,11 @@
 //
 // detail/handler_alloc_helpers.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_HANDLER_ALLOC_HELPERS_HPP
@@ -13,14 +13,13 @@
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
-#include <boost/detail/workaround.hpp>
-#include <boost/utility/addressof.hpp>
+#include <boost/asio/detail/addressof.hpp>
 #include <boost/asio/detail/noncopyable.hpp>
 #include <boost/asio/handler_alloc_hook.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 // Calls to asio_handler_allocate and asio_handler_deallocate must be made from
@@ -28,30 +27,28 @@
 // boost_asio_handler_alloc_helpers namespace is defined here for that purpose.
 namespace boost_asio_handler_alloc_helpers {
 
 template <typename Handler>
 inline void* allocate(std::size_t s, Handler& h)
 {
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) \
-  || BOOST_WORKAROUND(__GNUC__, < 3)
+#if !defined(BOOST_ASIO_HAS_HANDLER_HOOKS)
   return ::operator new(s);
 #else
   using boost::asio::asio_handler_allocate;
-  return asio_handler_allocate(s, boost::addressof(h));
+  return asio_handler_allocate(s, boost::asio::detail::addressof(h));
 #endif
 }
 
 template <typename Handler>
 inline void deallocate(void* p, std::size_t s, Handler& h)
 {
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) \
-  || BOOST_WORKAROUND(__GNUC__, < 3)
+#if !defined(BOOST_ASIO_HAS_HANDLER_HOOKS)
   ::operator delete(p);
 #else
   using boost::asio::asio_handler_deallocate;
-  asio_handler_deallocate(p, s, boost::addressof(h));
+  asio_handler_deallocate(p, s, boost::asio::detail::addressof(h));
 #endif
 }
 
 } // namespace boost_asio_handler_alloc_helpers
 
 #define BOOST_ASIO_DEFINE_HANDLER_PTR(op) \
diff --git a/3rdParty/Boost/src/boost/asio/detail/handler_cont_helpers.hpp b/3rdParty/Boost/src/boost/asio/detail/handler_cont_helpers.hpp
new file mode 100644
index 0000000..e318a6e
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/detail/handler_cont_helpers.hpp
@@ -0,0 +1,45 @@
+//
+// detail/handler_cont_helpers.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_DETAIL_HANDLER_CONT_HELPERS_HPP
+#define BOOST_ASIO_DETAIL_HANDLER_CONT_HELPERS_HPP
+
+#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/addressof.hpp>
+#include <boost/asio/handler_continuation_hook.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+// Calls to asio_handler_is_continuation must be made from a namespace that
+// does not contain overloads of this function. This namespace is defined here
+// for that purpose.
+namespace boost_asio_handler_cont_helpers {
+
+template <typename Context>
+inline bool is_continuation(Context& context)
+{
+#if !defined(BOOST_ASIO_HAS_HANDLER_HOOKS)
+  return false;
+#else
+  using boost::asio::asio_handler_is_continuation;
+  return asio_handler_is_continuation(
+      boost::asio::detail::addressof(context));
+#endif
+}
+
+} // namespace boost_asio_handler_cont_helpers
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_HANDLER_CONT_HELPERS_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/handler_invoke_helpers.hpp b/3rdParty/Boost/src/boost/asio/detail/handler_invoke_helpers.hpp
index f6172a0..ed276e5 100644
--- a/3rdParty/Boost/src/boost/asio/detail/handler_invoke_helpers.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/handler_invoke_helpers.hpp
@@ -1,11 +1,11 @@
 //
 // detail/handler_invoke_helpers.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_HANDLER_INVOKE_HELPERS_HPP
@@ -13,46 +13,43 @@
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
-#include <boost/detail/workaround.hpp>
-#include <boost/utility/addressof.hpp>
+#include <boost/asio/detail/addressof.hpp>
 #include <boost/asio/handler_invoke_hook.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 // Calls to asio_handler_invoke must be made from a namespace that does not
 // contain overloads of this function. The boost_asio_handler_invoke_helpers
 // namespace is defined here for that purpose.
 namespace boost_asio_handler_invoke_helpers {
 
 template <typename Function, typename Context>
 inline void invoke(Function& function, Context& context)
 {
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) \
-  || BOOST_WORKAROUND(__GNUC__, < 3)
+#if !defined(BOOST_ASIO_HAS_HANDLER_HOOKS)
   Function tmp(function);
   tmp();
 #else
   using boost::asio::asio_handler_invoke;
-  asio_handler_invoke(function, boost::addressof(context));
+  asio_handler_invoke(function, boost::asio::detail::addressof(context));
 #endif
 }
 
 template <typename Function, typename Context>
 inline void invoke(const Function& function, Context& context)
 {
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) \
-  || BOOST_WORKAROUND(__GNUC__, < 3)
+#if !defined(BOOST_ASIO_HAS_HANDLER_HOOKS)
   Function tmp(function);
   tmp();
 #else
   using boost::asio::asio_handler_invoke;
-  asio_handler_invoke(function, boost::addressof(context));
+  asio_handler_invoke(function, boost::asio::detail::addressof(context));
 #endif
 }
 
 } // namespace boost_asio_handler_invoke_helpers
 
 #include <boost/asio/detail/pop_options.hpp>
diff --git a/3rdParty/Boost/src/boost/asio/detail/handler_tracking.hpp b/3rdParty/Boost/src/boost/asio/detail/handler_tracking.hpp
index 9c96e18..9f31ddc 100644
--- a/3rdParty/Boost/src/boost/asio/detail/handler_tracking.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/handler_tracking.hpp
@@ -1,11 +1,11 @@
 //
 // detail/handler_tracking.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_HANDLER_TRACKING_HPP
@@ -15,14 +15,14 @@
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
 #if defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING)
-# include <boost/cstdint.hpp>
 # include <boost/system/error_code.hpp>
+# include <boost/asio/detail/cstdint.hpp>
 # include <boost/asio/detail/static_mutex.hpp>
 # include <boost/asio/detail/tss_ptr.hpp>
 #endif // defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING)
 
 #include <boost/asio/detail/push_options.hpp>
 
@@ -41,13 +41,13 @@ public:
   class tracked_handler
   {
   private:
     // Only the handler_tracking class will have access to the id.
     friend class handler_tracking;
     friend class completion;
-    boost::uint64_t id_;
+    uint64_t id_;
 
   protected:
     // Constructor initialises with no id.
     tracked_handler() : id_(0) {}
 
     // Prevent deletion through this type.
@@ -91,13 +91,13 @@ public:
 
     // Record that handler invocation has ended.
     BOOST_ASIO_DECL void invocation_end();
 
   private:
     friend class handler_tracking;
-    boost::uint64_t id_;
+    uint64_t id_;
     bool invoked_;
     completion* next_;
   };
 
   // Record an operation that affects pending handlers.
   BOOST_ASIO_DECL static void operation(const char* object_type,
diff --git a/3rdParty/Boost/src/boost/asio/detail/handler_type_requirements.hpp b/3rdParty/Boost/src/boost/asio/detail/handler_type_requirements.hpp
index a7f47c2..da111f1 100644
--- a/3rdParty/Boost/src/boost/asio/detail/handler_type_requirements.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/handler_type_requirements.hpp
@@ -1,11 +1,11 @@
 //
 // detail/handler_type_requirements.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_HANDLER_TYPE_REQUIREMENTS_HPP
@@ -34,19 +34,38 @@
 #  if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)) || (__GNUC__ > 4)
 #   if defined(__GXX_EXPERIMENTAL_CXX0X__)
 #    define BOOST_ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS_ASSERT 1
 #   endif // defined(__GXX_EXPERIMENTAL_CXX0X__)
 #  endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)) || (__GNUC__ > 4)
 # endif // defined(__GNUC__)
-# if defined(BOOST_MSVC)
+# if defined(BOOST_ASIO_MSVC)
 #  if (_MSC_VER >= 1600)
 #   define BOOST_ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS_ASSERT 1
 #  endif // (_MSC_VER >= 1600)
-# endif // defined(BOOST_MSVC)
+# endif // defined(BOOST_ASIO_MSVC)
+# if defined(__clang__)
+#  if __has_feature(__cxx_static_assert__)
+#   define BOOST_ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS_ASSERT 1
+#  endif // __has_feature(cxx_static_assert)
+# endif // defined(__clang__)
 #endif // !defined(BOOST_ASIO_DISABLE_HANDLER_TYPE_REQUIREMENTS)
 
+#if defined(BOOST_ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS)
+# include <boost/asio/handler_type.hpp>
+#endif // defined(BOOST_ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS)
+
+// Newer gcc needs special treatment to suppress unused typedef warnings.
+#if defined(__GNUC__)
+# if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 8)) || (__GNUC__ > 4)
+#  define BOOST_ASIO_UNUSED_TYPEDEF __attribute__((__unused__))
+# endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 8)) || (__GNUC__ > 4)
+#endif // defined(__GNUC__)
+#if !defined(BOOST_ASIO_UNUSED_TYPEDEF)
+# define BOOST_ASIO_UNUSED_TYPEDEF
+#endif // !defined(BOOST_ASIO_UNUSED_TYPEDEF)
+
 namespace boost {
 namespace asio {
 namespace detail {
 
 #if defined(BOOST_ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS)
 
@@ -90,271 +109,380 @@ char (&two_arg_handler_test(Handler, ...))[2];
 #  define BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT(expr, msg)
 
 # endif // defined(BOOST_ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS_ASSERT)
 
 template <typename T> T& lvref();
 template <typename T> T& lvref(T);
+template <typename T> const T& clvref();
 template <typename T> const T& clvref(T);
 template <typename T> char argbyv(T);
 
 template <int>
 struct handler_type_requirements
 {
 };
 
 #define BOOST_ASIO_COMPLETION_HANDLER_CHECK( \
     handler_type, handler) \
   \
+  typedef BOOST_ASIO_HANDLER_TYPE(handler_type, \
+      void()) asio_true_handler_type; \
+  \
   BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
       sizeof(boost::asio::detail::zero_arg_handler_test( \
-          handler, 0)) == 1, \
+          boost::asio::detail::clvref< \
+            asio_true_handler_type>(), 0)) == 1, \
       "CompletionHandler type requirements not met") \
   \
   typedef boost::asio::detail::handler_type_requirements< \
       sizeof( \
         boost::asio::detail::argbyv( \
-          boost::asio::detail::clvref(handler))) + \
+          boost::asio::detail::clvref< \
+            asio_true_handler_type>())) + \
       sizeof( \
-        boost::asio::detail::lvref(handler)(), \
-        char(0))>
+        boost::asio::detail::lvref< \
+          asio_true_handler_type>()(), \
+        char(0))> BOOST_ASIO_UNUSED_TYPEDEF
 
 #define BOOST_ASIO_READ_HANDLER_CHECK( \
     handler_type, handler) \
   \
+  typedef BOOST_ASIO_HANDLER_TYPE(handler_type, \
+      void(boost::system::error_code, std::size_t)) \
+    asio_true_handler_type; \
+  \
   BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
       sizeof(boost::asio::detail::two_arg_handler_test( \
-          handler, \
+          boost::asio::detail::clvref< \
+            asio_true_handler_type>(), \
           static_cast<const boost::system::error_code*>(0), \
           static_cast<const std::size_t*>(0))) == 1, \
       "ReadHandler type requirements not met") \
   \
   typedef boost::asio::detail::handler_type_requirements< \
       sizeof( \
         boost::asio::detail::argbyv( \
-          boost::asio::detail::clvref(handler))) + \
+          boost::asio::detail::clvref< \
+            asio_true_handler_type>())) + \
       sizeof( \
-        boost::asio::detail::lvref(handler)( \
-          boost::asio::detail::lvref<const boost::system::error_code>(), \
-          boost::asio::detail::lvref<const std::size_t>()), \
-        char(0))>
+        boost::asio::detail::lvref< \
+          asio_true_handler_type>()( \
+            boost::asio::detail::lvref<const boost::system::error_code>(), \
+            boost::asio::detail::lvref<const std::size_t>()), \
+        char(0))> BOOST_ASIO_UNUSED_TYPEDEF
+
 
 #define BOOST_ASIO_WRITE_HANDLER_CHECK( \
     handler_type, handler) \
   \
+  typedef BOOST_ASIO_HANDLER_TYPE(handler_type, \
+      void(boost::system::error_code, std::size_t)) \
+    asio_true_handler_type; \
+  \
   BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
       sizeof(boost::asio::detail::two_arg_handler_test( \
-          handler, \
+          boost::asio::detail::clvref< \
+            asio_true_handler_type>(), \
           static_cast<const boost::system::error_code*>(0), \
           static_cast<const std::size_t*>(0))) == 1, \
       "WriteHandler type requirements not met") \
   \
   typedef boost::asio::detail::handler_type_requirements< \
       sizeof( \
         boost::asio::detail::argbyv( \
-          boost::asio::detail::clvref(handler))) + \
+          boost::asio::detail::clvref< \
+            asio_true_handler_type>())) + \
       sizeof( \
-        boost::asio::detail::lvref(handler)( \
-          boost::asio::detail::lvref<const boost::system::error_code>(), \
-          boost::asio::detail::lvref<const std::size_t>()), \
-        char(0))>
+        boost::asio::detail::lvref< \
+          asio_true_handler_type>()( \
+            boost::asio::detail::lvref<const boost::system::error_code>(), \
+            boost::asio::detail::lvref<const std::size_t>()), \
+        char(0))> BOOST_ASIO_UNUSED_TYPEDEF
 
 #define BOOST_ASIO_ACCEPT_HANDLER_CHECK( \
     handler_type, handler) \
   \
+  typedef BOOST_ASIO_HANDLER_TYPE(handler_type, \
+      void(boost::system::error_code)) \
+    asio_true_handler_type; \
+  \
   BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
       sizeof(boost::asio::detail::one_arg_handler_test( \
-          handler, \
+          boost::asio::detail::clvref< \
+            asio_true_handler_type>(), \
           static_cast<const boost::system::error_code*>(0))) == 1, \
       "AcceptHandler type requirements not met") \
   \
   typedef boost::asio::detail::handler_type_requirements< \
       sizeof( \
         boost::asio::detail::argbyv( \
-          boost::asio::detail::clvref(handler))) + \
+          boost::asio::detail::clvref< \
+            asio_true_handler_type>())) + \
       sizeof( \
-        boost::asio::detail::lvref(handler)( \
-          boost::asio::detail::lvref<const boost::system::error_code>()), \
-        char(0))>
+        boost::asio::detail::lvref< \
+          asio_true_handler_type>()( \
+            boost::asio::detail::lvref<const boost::system::error_code>()), \
+        char(0))> BOOST_ASIO_UNUSED_TYPEDEF
 
 #define BOOST_ASIO_CONNECT_HANDLER_CHECK( \
     handler_type, handler) \
   \
+  typedef BOOST_ASIO_HANDLER_TYPE(handler_type, \
+      void(boost::system::error_code)) \
+    asio_true_handler_type; \
+  \
   BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
       sizeof(boost::asio::detail::one_arg_handler_test( \
-          handler, \
+          boost::asio::detail::clvref< \
+            asio_true_handler_type>(), \
           static_cast<const boost::system::error_code*>(0))) == 1, \
       "ConnectHandler type requirements not met") \
   \
   typedef boost::asio::detail::handler_type_requirements< \
       sizeof( \
         boost::asio::detail::argbyv( \
-          boost::asio::detail::clvref(handler))) + \
+          boost::asio::detail::clvref< \
+            asio_true_handler_type>())) + \
       sizeof( \
-        boost::asio::detail::lvref(handler)( \
-          boost::asio::detail::lvref<const boost::system::error_code>()), \
-        char(0))>
+        boost::asio::detail::lvref< \
+          asio_true_handler_type>()( \
+            boost::asio::detail::lvref<const boost::system::error_code>()), \
+        char(0))> BOOST_ASIO_UNUSED_TYPEDEF
 
 #define BOOST_ASIO_COMPOSED_CONNECT_HANDLER_CHECK( \
     handler_type, handler, iter_type) \
   \
+  typedef BOOST_ASIO_HANDLER_TYPE(handler_type, \
+      void(boost::system::error_code, iter_type)) \
+    asio_true_handler_type; \
+  \
   BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
       sizeof(boost::asio::detail::two_arg_handler_test( \
-          handler, \
+          boost::asio::detail::clvref< \
+            asio_true_handler_type>(), \
           static_cast<const boost::system::error_code*>(0), \
           static_cast<const iter_type*>(0))) == 1, \
       "ComposedConnectHandler type requirements not met") \
   \
   typedef boost::asio::detail::handler_type_requirements< \
       sizeof( \
         boost::asio::detail::argbyv( \
-          boost::asio::detail::clvref(handler))) + \
+          boost::asio::detail::clvref< \
+            asio_true_handler_type>())) + \
       sizeof( \
-        boost::asio::detail::lvref(handler)( \
-          boost::asio::detail::lvref<const boost::system::error_code>(), \
-          boost::asio::detail::lvref<const iter_type>()), \
-        char(0))>
+        boost::asio::detail::lvref< \
+          asio_true_handler_type>()( \
+            boost::asio::detail::lvref<const boost::system::error_code>(), \
+            boost::asio::detail::lvref<const iter_type>()), \
+        char(0))> BOOST_ASIO_UNUSED_TYPEDEF
 
 #define BOOST_ASIO_RESOLVE_HANDLER_CHECK( \
     handler_type, handler, iter_type) \
   \
+  typedef BOOST_ASIO_HANDLER_TYPE(handler_type, \
+      void(boost::system::error_code, iter_type)) \
+    asio_true_handler_type; \
+  \
   BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
       sizeof(boost::asio::detail::two_arg_handler_test( \
-          handler, \
+          boost::asio::detail::clvref< \
+            asio_true_handler_type>(), \
           static_cast<const boost::system::error_code*>(0), \
           static_cast<const iter_type*>(0))) == 1, \
       "ResolveHandler type requirements not met") \
   \
   typedef boost::asio::detail::handler_type_requirements< \
       sizeof( \
         boost::asio::detail::argbyv( \
-          boost::asio::detail::clvref(handler))) + \
+          boost::asio::detail::clvref< \
+            asio_true_handler_type>())) + \
       sizeof( \
-        boost::asio::detail::lvref(handler)( \
-          boost::asio::detail::lvref<const boost::system::error_code>(), \
-          boost::asio::detail::lvref<const iter_type>()), \
-        char(0))>
+        boost::asio::detail::lvref< \
+          asio_true_handler_type>()( \
+            boost::asio::detail::lvref<const boost::system::error_code>(), \
+            boost::asio::detail::lvref<const iter_type>()), \
+        char(0))> BOOST_ASIO_UNUSED_TYPEDEF
 
 #define BOOST_ASIO_WAIT_HANDLER_CHECK( \
     handler_type, handler) \
   \
+  typedef BOOST_ASIO_HANDLER_TYPE(handler_type, \
+      void(boost::system::error_code)) \
+    asio_true_handler_type; \
+  \
   BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
       sizeof(boost::asio::detail::one_arg_handler_test( \
-          handler, \
+          boost::asio::detail::clvref< \
+            asio_true_handler_type>(), \
           static_cast<const boost::system::error_code*>(0))) == 1, \
       "WaitHandler type requirements not met") \
   \
   typedef boost::asio::detail::handler_type_requirements< \
       sizeof( \
         boost::asio::detail::argbyv( \
-          boost::asio::detail::clvref(handler))) + \
+          boost::asio::detail::clvref< \
+            asio_true_handler_type>())) + \
       sizeof( \
-        boost::asio::detail::lvref(handler)( \
-          boost::asio::detail::lvref<const boost::system::error_code>()), \
-        char(0))>
+        boost::asio::detail::lvref< \
+          asio_true_handler_type>()( \
+            boost::asio::detail::lvref<const boost::system::error_code>()), \
+        char(0))> BOOST_ASIO_UNUSED_TYPEDEF
 
 #define BOOST_ASIO_SIGNAL_HANDLER_CHECK( \
     handler_type, handler) \
   \
+  typedef BOOST_ASIO_HANDLER_TYPE(handler_type, \
+      void(boost::system::error_code, int)) \
+    asio_true_handler_type; \
+  \
   BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
       sizeof(boost::asio::detail::two_arg_handler_test( \
-          handler, \
+          boost::asio::detail::clvref< \
+            asio_true_handler_type>(), \
           static_cast<const boost::system::error_code*>(0), \
           static_cast<const int*>(0))) == 1, \
       "SignalHandler type requirements not met") \
   \
   typedef boost::asio::detail::handler_type_requirements< \
       sizeof( \
         boost::asio::detail::argbyv( \
-          boost::asio::detail::clvref(handler))) + \
+          boost::asio::detail::clvref< \
+            asio_true_handler_type>())) + \
       sizeof( \
-        boost::asio::detail::lvref(handler)( \
-          boost::asio::detail::lvref<const boost::system::error_code>(), \
-          boost::asio::detail::lvref<const int>()), \
-        char(0))>
+        boost::asio::detail::lvref< \
+          asio_true_handler_type>()( \
+            boost::asio::detail::lvref<const boost::system::error_code>(), \
+            boost::asio::detail::lvref<const int>()), \
+        char(0))> BOOST_ASIO_UNUSED_TYPEDEF
 
 #define BOOST_ASIO_HANDSHAKE_HANDLER_CHECK( \
     handler_type, handler) \
   \
+  typedef BOOST_ASIO_HANDLER_TYPE(handler_type, \
+      void(boost::system::error_code)) \
+    asio_true_handler_type; \
+  \
   BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
       sizeof(boost::asio::detail::one_arg_handler_test( \
-          handler, \
+          boost::asio::detail::clvref< \
+            asio_true_handler_type>(), \
           static_cast<const boost::system::error_code*>(0))) == 1, \
       "HandshakeHandler type requirements not met") \
   \
   typedef boost::asio::detail::handler_type_requirements< \
       sizeof( \
         boost::asio::detail::argbyv( \
-          boost::asio::detail::clvref(handler))) + \
+          boost::asio::detail::clvref< \
+            asio_true_handler_type>())) + \
       sizeof( \
-        boost::asio::detail::lvref(handler)( \
-          boost::asio::detail::lvref<const boost::system::error_code>()), \
-        char(0))>
+        boost::asio::detail::lvref< \
+          asio_true_handler_type>()( \
+            boost::asio::detail::lvref<const boost::system::error_code>()), \
+        char(0))> BOOST_ASIO_UNUSED_TYPEDEF
+
+#define BOOST_ASIO_BUFFERED_HANDSHAKE_HANDLER_CHECK( \
+    handler_type, handler) \
+  \
+  typedef BOOST_ASIO_HANDLER_TYPE(handler_type, \
+      void(boost::system::error_code, std::size_t)) \
+    asio_true_handler_type; \
+  \
+  BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
+      sizeof(boost::asio::detail::two_arg_handler_test( \
+          boost::asio::detail::clvref< \
+            asio_true_handler_type>(), \
+          static_cast<const boost::system::error_code*>(0), \
+          static_cast<const std::size_t*>(0))) == 1, \
+      "BufferedHandshakeHandler type requirements not met") \
+  \
+  typedef boost::asio::detail::handler_type_requirements< \
+      sizeof( \
+        boost::asio::detail::argbyv( \
+          boost::asio::detail::clvref< \
+            asio_true_handler_type>())) + \
+      sizeof( \
+        boost::asio::detail::lvref< \
+          asio_true_handler_type>()( \
+          boost::asio::detail::lvref<const boost::system::error_code>(), \
+          boost::asio::detail::lvref<const std::size_t>()), \
+        char(0))> BOOST_ASIO_UNUSED_TYPEDEF
 
 #define BOOST_ASIO_SHUTDOWN_HANDLER_CHECK( \
     handler_type, handler) \
   \
+  typedef BOOST_ASIO_HANDLER_TYPE(handler_type, \
+      void(boost::system::error_code)) \
+    asio_true_handler_type; \
+  \
   BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
       sizeof(boost::asio::detail::one_arg_handler_test( \
-          handler, \
+          boost::asio::detail::clvref< \
+            asio_true_handler_type>(), \
           static_cast<const boost::system::error_code*>(0))) == 1, \
       "ShutdownHandler type requirements not met") \
   \
   typedef boost::asio::detail::handler_type_requirements< \
       sizeof( \
         boost::asio::detail::argbyv( \
-          boost::asio::detail::clvref(handler))) + \
+          boost::asio::detail::clvref< \
+            asio_true_handler_type>())) + \
       sizeof( \
-        boost::asio::detail::lvref(handler)( \
-          boost::asio::detail::lvref<const boost::system::error_code>()), \
-        char(0))>
+        boost::asio::detail::lvref< \
+          asio_true_handler_type>()( \
+            boost::asio::detail::lvref<const boost::system::error_code>()), \
+        char(0))> BOOST_ASIO_UNUSED_TYPEDEF
 
 #else // !defined(BOOST_ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS)
 
 #define BOOST_ASIO_COMPLETION_HANDLER_CHECK( \
     handler_type, handler) \
-  typedef int
+  typedef int BOOST_ASIO_UNUSED_TYPEDEF
 
 #define BOOST_ASIO_READ_HANDLER_CHECK( \
     handler_type, handler) \
-  typedef int
+  typedef int BOOST_ASIO_UNUSED_TYPEDEF
 
 #define BOOST_ASIO_WRITE_HANDLER_CHECK( \
     handler_type, handler) \
-  typedef int
+  typedef int BOOST_ASIO_UNUSED_TYPEDEF
 
 #define BOOST_ASIO_ACCEPT_HANDLER_CHECK( \
     handler_type, handler) \
-  typedef int
+  typedef int BOOST_ASIO_UNUSED_TYPEDEF
 
 #define BOOST_ASIO_CONNECT_HANDLER_CHECK( \
     handler_type, handler) \
-  typedef int
+  typedef int BOOST_ASIO_UNUSED_TYPEDEF
 
 #define BOOST_ASIO_COMPOSED_CONNECT_HANDLER_CHECK( \
     handler_type, handler, iter_type) \
-  typedef int
+  typedef int BOOST_ASIO_UNUSED_TYPEDEF
 
 #define BOOST_ASIO_RESOLVE_HANDLER_CHECK( \
     handler_type, handler, iter_type) \
-  typedef int
+  typedef int BOOST_ASIO_UNUSED_TYPEDEF
 
 #define BOOST_ASIO_WAIT_HANDLER_CHECK( \
     handler_type, handler) \
-  typedef int
+  typedef int BOOST_ASIO_UNUSED_TYPEDEF
 
 #define BOOST_ASIO_SIGNAL_HANDLER_CHECK( \
     handler_type, handler) \
-  typedef int
+  typedef int BOOST_ASIO_UNUSED_TYPEDEF
 
 #define BOOST_ASIO_HANDSHAKE_HANDLER_CHECK( \
     handler_type, handler) \
-  typedef int
+  typedef int BOOST_ASIO_UNUSED_TYPEDEF
+
+#define BOOST_ASIO_BUFFERED_HANDSHAKE_HANDLER_CHECK( \
+    handler_type, handler) \
+  typedef int BOOST_ASIO_UNUSED_TYPEDEF
 
 #define BOOST_ASIO_SHUTDOWN_HANDLER_CHECK( \
     handler_type, handler) \
-  typedef int
+  typedef int BOOST_ASIO_UNUSED_TYPEDEF
 
 #endif // !defined(BOOST_ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS)
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
diff --git a/3rdParty/Boost/src/boost/asio/detail/hash_map.hpp b/3rdParty/Boost/src/boost/asio/detail/hash_map.hpp
index 339ab9d..6724a24 100644
--- a/3rdParty/Boost/src/boost/asio/detail/hash_map.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/hash_map.hpp
@@ -1,11 +1,11 @@
 //
 // detail/hash_map.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_HASH_MAP_HPP
@@ -13,20 +13,20 @@
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
-#include <boost/assert.hpp>
 #include <list>
 #include <utility>
+#include <boost/asio/detail/assert.hpp>
 #include <boost/asio/detail/noncopyable.hpp>
 
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 # include <boost/asio/detail/socket_types.hpp>
-#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
@@ -39,18 +39,18 @@ inline std::size_t calculate_hash_value(int i)
 inline std::size_t calculate_hash_value(void* p)
 {
   return reinterpret_cast<std::size_t>(p)
     + (reinterpret_cast<std::size_t>(p) >> 3);
 }
 
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 inline std::size_t calculate_hash_value(SOCKET s)
 {
   return static_cast<std::size_t>(s);
 }
-#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 
 // Note: assumes K and V are POD types.
 template <typename K, typename V>
 class hash_map
   : private noncopyable
 {
@@ -177,13 +177,14 @@ public:
     return std::pair<iterator, bool>(buckets_[bucket].last, true);
   }
 
   // Erase an entry from the map.
   void erase(iterator it)
   {
-    BOOST_ASSERT(it != values_.end());
+    BOOST_ASIO_ASSERT(it != values_.end());
+    BOOST_ASIO_ASSERT(num_buckets_ != 0);
 
     size_t bucket = calculate_hash_value(it->first) % num_buckets_;
     bool is_first = (it == buckets_[bucket].first);
     bool is_last = (it == buckets_[bucket].last);
     if (is_first && is_last)
       buckets_[bucket].first = buckets_[bucket].last = values_.end();
@@ -241,12 +242,13 @@ private:
   // Re-initialise the hash from the values already contained in the list.
   void rehash(std::size_t num_buckets)
   {
     if (num_buckets == num_buckets_)
       return;
     num_buckets_ = num_buckets;
+    BOOST_ASIO_ASSERT(num_buckets_ != 0);
 
     iterator end_iter = values_.end();
 
     // Update number of buckets and initialise all buckets to empty.
     bucket_type* tmp = new bucket_type[num_buckets_];
     delete[] buckets_;
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/buffer_sequence_adapter.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/buffer_sequence_adapter.ipp
new file mode 100644
index 0000000..a538134
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/buffer_sequence_adapter.ipp
@@ -0,0 +1,120 @@
+//
+// detail/impl/buffer_sequence_adapter.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_DETAIL_IMPL_BUFFER_SEQUENCE_ADAPTER_IPP
+#define BOOST_ASIO_DETAIL_IMPL_BUFFER_SEQUENCE_ADAPTER_IPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_WINDOWS_RUNTIME)
+
+#include <robuffer.h>
+#include <windows.storage.streams.h>
+#include <wrl/implements.h>
+#include <boost/asio/detail/buffer_sequence_adapter.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+class winrt_buffer_impl :
+  public Microsoft::WRL::RuntimeClass<
+    Microsoft::WRL::RuntimeClassFlags<
+      Microsoft::WRL::RuntimeClassType::WinRtClassicComMix>,
+    ABI::Windows::Storage::Streams::IBuffer,
+    Windows::Storage::Streams::IBufferByteAccess>
+{
+public:
+  explicit winrt_buffer_impl(const boost::asio::const_buffer& b)
+  {
+    bytes_ = const_cast<byte*>(boost::asio::buffer_cast<const byte*>(b));
+    length_ = boost::asio::buffer_size(b);
+    capacity_ = boost::asio::buffer_size(b);
+  }
+
+  explicit winrt_buffer_impl(const boost::asio::mutable_buffer& b)
+  {
+    bytes_ = const_cast<byte*>(boost::asio::buffer_cast<const byte*>(b));
+    length_ = 0;
+    capacity_ = boost::asio::buffer_size(b);
+  }
+
+  ~winrt_buffer_impl()
+  {
+  }
+
+  STDMETHODIMP Buffer(byte** value)
+  {
+    *value = bytes_;
+    return S_OK;
+  }
+
+  STDMETHODIMP get_Capacity(UINT32* value)
+  {
+    *value = capacity_;
+    return S_OK;
+  }
+
+  STDMETHODIMP get_Length(UINT32 *value)
+  {
+    *value = length_;
+    return S_OK;
+  }
+
+  STDMETHODIMP put_Length(UINT32 value)
+  {
+    if (value > capacity_)
+      return E_INVALIDARG;
+    length_ = value;
+    return S_OK;
+  }
+
+private:
+  byte* bytes_;
+  UINT32 length_;
+  UINT32 capacity_;
+};
+
+void buffer_sequence_adapter_base::init_native_buffer(
+    buffer_sequence_adapter_base::native_buffer_type& buf,
+    const boost::asio::mutable_buffer& buffer)
+{
+  std::memset(&buf, 0, sizeof(native_buffer_type));
+  Microsoft::WRL::ComPtr<IInspectable> insp
+    = Microsoft::WRL::Make<winrt_buffer_impl>(buffer);
+  buf = reinterpret_cast<Windows::Storage::Streams::IBuffer^>(insp.Get());
+}
+
+void buffer_sequence_adapter_base::init_native_buffer(
+    buffer_sequence_adapter_base::native_buffer_type& buf,
+    const boost::asio::const_buffer& buffer)
+{
+  std::memset(&buf, 0, sizeof(native_buffer_type));
+  Microsoft::WRL::ComPtr<IInspectable> insp
+    = Microsoft::WRL::Make<winrt_buffer_impl>(buffer);
+  Platform::Object^ buf_obj = reinterpret_cast<Platform::Object^>(insp.Get());
+  buf = reinterpret_cast<Windows::Storage::Streams::IBuffer^>(insp.Get());
+}
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // defined(BOOST_ASIO_WINDOWS_RUNTIME)
+
+#endif // BOOST_ASIO_DETAIL_IMPL_BUFFER_SEQUENCE_ADAPTER_IPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/descriptor_ops.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/descriptor_ops.ipp
index 6c3528f..54b8537 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/descriptor_ops.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/descriptor_ops.ipp
@@ -1,11 +1,11 @@
 //
 // detail/impl/descriptor_ops.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_IMPL_DESCRIPTOR_OPS_IPP
@@ -17,13 +17,15 @@
 
 #include <boost/asio/detail/config.hpp>
 #include <cerrno>
 #include <boost/asio/detail/descriptor_ops.hpp>
 #include <boost/asio/error.hpp>
 
-#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+#if !defined(BOOST_ASIO_WINDOWS) \
+  && !defined(BOOST_ASIO_WINDOWS_RUNTIME) \
+  && !defined(__CYGWIN__)
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
@@ -180,13 +182,14 @@ std::size_t sync_read(int d, state_type state, buf* bufs,
 
   // Read some data.
   for (;;)
   {
     // Try to complete the operation without blocking.
     errno = 0;
-    int bytes = error_wrapper(::readv(d, bufs, static_cast<int>(count)), ec);
+    signed_size_type bytes = error_wrapper(::readv(
+          d, bufs, static_cast<int>(count)), ec);
 
     // Check if operation succeeded.
     if (bytes > 0)
       return bytes;
 
     // Check for EOF.
@@ -212,13 +215,14 @@ bool non_blocking_read(int d, buf* bufs, std::size_t count,
     boost::system::error_code& ec, std::size_t& bytes_transferred)
 {
   for (;;)
   {
     // Read some data.
     errno = 0;
-    int bytes = error_wrapper(::readv(d, bufs, static_cast<int>(count)), ec);
+    signed_size_type bytes = error_wrapper(::readv(
+          d, bufs, static_cast<int>(count)), ec);
 
     // Check for end of stream.
     if (bytes == 0)
     {
       ec = boost::asio::error::eof;
       return true;
@@ -264,13 +268,14 @@ std::size_t sync_write(int d, state_type state, const buf* bufs,
 
   // Write some data.
   for (;;)
   {
     // Try to complete the operation without blocking.
     errno = 0;
-    int bytes = error_wrapper(::writev(d, bufs, static_cast<int>(count)), ec);
+    signed_size_type bytes = error_wrapper(::writev(
+          d, bufs, static_cast<int>(count)), ec);
 
     // Check if operation succeeded.
     if (bytes > 0)
       return bytes;
 
     // Operation failed.
@@ -289,13 +294,14 @@ bool non_blocking_write(int d, const buf* bufs, std::size_t count,
     boost::system::error_code& ec, std::size_t& bytes_transferred)
 {
   for (;;)
   {
     // Write some data.
     errno = 0;
-    int bytes = error_wrapper(::writev(d, bufs, static_cast<int>(count)), ec);
+    signed_size_type bytes = error_wrapper(::writev(
+          d, bufs, static_cast<int>(count)), ec);
 
     // Retry operation if interrupted by signal.
     if (ec == boost::asio::error::interrupted)
       continue;
 
     // Check if we need to run the operation again.
@@ -354,13 +360,13 @@ int ioctl(int d, state_type& state, long cmd,
     }
   }
 
   return result;
 }
 
-int fcntl(int d, long cmd, boost::system::error_code& ec)
+int fcntl(int d, int cmd, boost::system::error_code& ec)
 {
   if (d == -1)
   {
     ec = boost::asio::error::bad_descriptor;
     return -1;
   }
@@ -369,13 +375,13 @@ int fcntl(int d, long cmd, boost::system::error_code& ec)
   int result = error_wrapper(::fcntl(d, cmd), ec);
   if (result != -1)
     ec = boost::system::error_code();
   return result;
 }
 
-int fcntl(int d, long cmd, long arg, boost::system::error_code& ec)
+int fcntl(int d, int cmd, long arg, boost::system::error_code& ec)
 {
   if (d == -1)
   {
     ec = boost::asio::error::bad_descriptor;
     return -1;
   }
@@ -437,9 +443,11 @@ int poll_write(int d, state_type state, boost::system::error_code& ec)
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
-#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+#endif // !defined(BOOST_ASIO_WINDOWS)
+       //   && !defined(BOOST_ASIO_WINDOWS_RUNTIME)
+       //   && !defined(__CYGWIN__)
 
 #endif // BOOST_ASIO_DETAIL_IMPL_DESCRIPTOR_OPS_IPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/dev_poll_reactor.hpp b/3rdParty/Boost/src/boost/asio/detail/impl/dev_poll_reactor.hpp
index 12860af..1c02ea4 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/dev_poll_reactor.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/dev_poll_reactor.hpp
@@ -1,11 +1,11 @@
 //
 // detail/impl/dev_poll_reactor.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_IMPL_DEV_POLL_REACTOR_HPP
@@ -43,13 +43,13 @@ void dev_poll_reactor::schedule_timer(timer_queue<Time_Traits>& queue,
     typename timer_queue<Time_Traits>::per_timer_data& timer, wait_op* op)
 {
   boost::asio::detail::mutex::scoped_lock lock(mutex_);
 
   if (shutdown_)
   {
-    io_service_.post_immediate_completion(op);
+    io_service_.post_immediate_completion(op, false);
     return;
   }
 
   bool earliest = queue.enqueue_timer(time, timer, op);
   io_service_.work_started();
   if (earliest)
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/dev_poll_reactor.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/dev_poll_reactor.ipp
index a648bf1..cc5b401 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/dev_poll_reactor.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/dev_poll_reactor.ipp
@@ -1,11 +1,11 @@
 //
 // detail/impl/dev_poll_reactor.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_IMPL_DEV_POLL_REACTOR_IPP
@@ -16,14 +16,14 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
 #if defined(BOOST_ASIO_HAS_DEV_POLL)
 
-#include <boost/assert.hpp>
 #include <boost/asio/detail/dev_poll_reactor.hpp>
+#include <boost/asio/detail/assert.hpp>
 #include <boost/asio/detail/throw_error.hpp>
 #include <boost/asio/error.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
@@ -119,13 +119,13 @@ void dev_poll_reactor::fork_service(boost::asio::io_service::fork_event fork_ev)
     fork_helper except_op_helper(this, POLLERR | POLLHUP | POLLPRI);
     op_queue_[except_op].get_descriptors(except_op_helper, ops);
     interrupter_.interrupt();
 
     // The ops op_queue will always be empty because the fork_helper's set()
     // member function never returns false.
-    BOOST_ASSERT(ops.empty());
+    BOOST_ASIO_ASSERT(ops.empty());
   }
 }
 
 void dev_poll_reactor::init_task()
 {
   io_service_.init_task();
@@ -160,33 +160,33 @@ void dev_poll_reactor::move_descriptor(socket_type,
     dev_poll_reactor::per_descriptor_data&,
     dev_poll_reactor::per_descriptor_data&)
 {
 }
 
 void dev_poll_reactor::start_op(int op_type, socket_type descriptor,
-    dev_poll_reactor::per_descriptor_data&,
-    reactor_op* op, bool allow_speculative)
+    dev_poll_reactor::per_descriptor_data&, reactor_op* op,
+    bool is_continuation, bool allow_speculative)
 {
   boost::asio::detail::mutex::scoped_lock lock(mutex_);
 
   if (shutdown_)
   {
-    post_immediate_completion(op);
+    post_immediate_completion(op, is_continuation);
     return;
   }
 
   if (allow_speculative)
   {
     if (op_type != read_op || !op_queue_[except_op].has_operation(descriptor))
     {
       if (!op_queue_[op_type].has_operation(descriptor))
       {
         if (op->perform())
         {
           lock.unlock();
-          io_service_.post_immediate_completion(op);
+          io_service_.post_immediate_completion(op, is_continuation);
           return;
         }
       }
     }
   }
 
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/epoll_reactor.hpp b/3rdParty/Boost/src/boost/asio/detail/impl/epoll_reactor.hpp
index 215f484..3a08f8e 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/epoll_reactor.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/epoll_reactor.hpp
@@ -1,11 +1,11 @@
 //
 // detail/impl/epoll_reactor.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_IMPL_EPOLL_REACTOR_HPP
@@ -41,13 +41,13 @@ void epoll_reactor::schedule_timer(timer_queue<Time_Traits>& queue,
     typename timer_queue<Time_Traits>::per_timer_data& timer, wait_op* op)
 {
   mutex::scoped_lock lock(mutex_);
 
   if (shutdown_)
   {
-    io_service_.post_immediate_completion(op);
+    io_service_.post_immediate_completion(op, false);
     return;
   }
 
   bool earliest = queue.enqueue_timer(time, timer, op);
   io_service_.work_started();
   if (earliest)
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/epoll_reactor.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/epoll_reactor.ipp
index 073bd08..27408e4 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/epoll_reactor.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/epoll_reactor.ipp
@@ -1,11 +1,11 @@
 //
 // detail/impl/epoll_reactor.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_IMPL_EPOLL_REACTOR_IPP
@@ -201,40 +201,40 @@ void epoll_reactor::move_descriptor(socket_type,
 {
   target_descriptor_data = source_descriptor_data;
   source_descriptor_data = 0;
 }
 
 void epoll_reactor::start_op(int op_type, socket_type descriptor,
-    epoll_reactor::per_descriptor_data& descriptor_data,
-    reactor_op* op, bool allow_speculative)
+    epoll_reactor::per_descriptor_data& descriptor_data, reactor_op* op,
+    bool is_continuation, bool allow_speculative)
 {
   if (!descriptor_data)
   {
     op->ec_ = boost::asio::error::bad_descriptor;
-    post_immediate_completion(op);
+    post_immediate_completion(op, is_continuation);
     return;
   }
 
   mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
 
   if (descriptor_data->shutdown_)
   {
-    post_immediate_completion(op);
+    post_immediate_completion(op, is_continuation);
     return;
   }
 
   if (descriptor_data->op_queue_[op_type].empty())
   {
     if (allow_speculative
         && (op_type != read_op
           || descriptor_data->op_queue_[except_op].empty()))
     {
       if (op->perform())
       {
         descriptor_lock.unlock();
-        io_service_.post_immediate_completion(op);
+        io_service_.post_immediate_completion(op, is_continuation);
         return;
       }
 
       if (op_type == write_op)
       {
         if ((descriptor_data->registered_events_ & EPOLLOUT) == 0)
@@ -247,13 +247,13 @@ void epoll_reactor::start_op(int op_type, socket_type descriptor,
             descriptor_data->registered_events_ |= ev.events;
           }
           else
           {
             op->ec_ = boost::system::error_code(errno,
                 boost::asio::error::get_system_category());
-            io_service_.post_immediate_completion(op);
+            io_service_.post_immediate_completion(op, is_continuation);
             return;
           }
         }
       }
     }
     else
@@ -604,14 +604,15 @@ epoll_reactor::descriptor_state::descriptor_state()
   : operation(&epoll_reactor::descriptor_state::do_complete)
 {
 }
 
 operation* epoll_reactor::descriptor_state::perform_io(uint32_t events)
 {
+  mutex_.lock();
   perform_io_cleanup_on_block_exit io_cleanup(reactor_);
-  mutex::scoped_lock descriptor_lock(mutex_);
+  mutex::scoped_lock descriptor_lock(mutex_, mutex::scoped_lock::adopt_lock);
 
   // Exception operations must be processed first to ensure that any
   // out-of-band data is read before normal data.
   static const int flag[max_ops] = { EPOLLIN, EPOLLOUT, EPOLLPRI };
   for (int j = max_ops - 1; j >= 0; --j)
   {
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/eventfd_select_interrupter.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/eventfd_select_interrupter.ipp
index 22154bb..c5a673a 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/eventfd_select_interrupter.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/eventfd_select_interrupter.ipp
@@ -1,11 +1,11 @@
 //
 // detail/impl/eventfd_select_interrupter.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 Roelof Naude (roelof.naude at gmail 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)
 //
 
@@ -25,12 +25,13 @@
 #include <fcntl.h>
 #if __GLIBC__ == 2 && __GLIBC_MINOR__ < 8
 # include <asm/unistd.h>
 #else // __GLIBC__ == 2 && __GLIBC_MINOR__ < 8
 # include <sys/eventfd.h>
 #endif // __GLIBC__ == 2 && __GLIBC_MINOR__ < 8
+#include <boost/asio/detail/cstdint.hpp>
 #include <boost/asio/detail/eventfd_select_interrupter.hpp>
 #include <boost/asio/detail/throw_error.hpp>
 #include <boost/asio/error.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/handler_tracking.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/handler_tracking.ipp
index 70342e3..2c84e5a 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/handler_tracking.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/handler_tracking.ipp
@@ -1,11 +1,11 @@
 //
 // detail/impl/handler_tracking.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_IMPL_HANDLER_TRACKING_IPP
@@ -20,30 +20,65 @@
 #if defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING)
 
 #include <cstdarg>
 #include <cstdio>
 #include <boost/asio/detail/handler_tracking.hpp>
 
-#include <boost/asio/detail/push_options.hpp>
-#include <boost/date_time/posix_time/posix_time_types.hpp>
-#include <boost/asio/detail/pop_options.hpp>
-
-#if !defined(BOOST_WINDOWS)
+#if defined(BOOST_ASIO_HAS_BOOST_DATE_TIME)
+# include <boost/asio/time_traits.hpp>
+#else // defined(BOOST_ASIO_HAS_BOOST_DATE_TIME)
+# if defined(BOOST_ASIO_HAS_STD_CHRONO)
+#  include <chrono>
+# elif defined(BOOST_ASIO_HAS_BOOST_CHRONO)
+#  include <boost/chrono/system_clocks.hpp>
+# endif
+# include <boost/asio/detail/chrono_time_traits.hpp>
+# include <boost/asio/wait_traits.hpp>
+#endif // defined(BOOST_ASIO_HAS_BOOST_DATE_TIME)
+
+#if !defined(BOOST_ASIO_WINDOWS)
 # include <unistd.h>
-#endif // !defined(BOOST_WINDOWS)
+#endif // !defined(BOOST_ASIO_WINDOWS)
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
+struct handler_tracking_timestamp
+{
+  uint64_t seconds;
+  uint64_t microseconds;
+
+  handler_tracking_timestamp()
+  {
+#if defined(BOOST_ASIO_HAS_BOOST_DATE_TIME)
+    boost::posix_time::ptime epoch(boost::gregorian::date(1970, 1, 1));
+    boost::posix_time::time_duration now =
+      boost::posix_time::microsec_clock::universal_time() - epoch;
+#elif defined(BOOST_ASIO_HAS_STD_CHRONO)
+    typedef chrono_time_traits<std::chrono::system_clock,
+        boost::asio::wait_traits<std::chrono::system_clock> > traits_helper;
+    traits_helper::posix_time_duration now(
+        std::chrono::system_clock::now().time_since_epoch());
+#elif defined(BOOST_ASIO_HAS_BOOST_CHRONO)
+    typedef chrono_time_traits<boost::chrono::system_clock,
+        boost::asio::wait_traits<boost::chrono::system_clock> > traits_helper;
+    traits_helper::posix_time_duration now(
+        boost::chrono::system_clock::now().time_since_epoch());
+#endif
+    seconds = static_cast<uint64_t>(now.total_seconds());
+    microseconds = static_cast<uint64_t>(now.total_microseconds() % 1000000);
+  }
+};
+
 struct handler_tracking::tracking_state
 {
   static_mutex mutex_;
-  boost::uint64_t next_id_;
+  uint64_t next_id_;
   tss_ptr<completion>* current_completion_;
 };
 
 handler_tracking::tracking_state* handler_tracking::get_state()
 {
   static tracking_state state = { BOOST_ASIO_STATIC_MUTEX_INIT, 1, 0 };
@@ -67,28 +102,25 @@ void handler_tracking::creation(handler_tracking::tracked_handler* h,
   static tracking_state* state = get_state();
 
   static_mutex::scoped_lock lock(state->mutex_);
   h->id_ = state->next_id_++;
   lock.unlock();
 
-  boost::posix_time::ptime epoch(boost::gregorian::date(1970, 1, 1));
-  boost::posix_time::time_duration now =
-    boost::posix_time::microsec_clock::universal_time() - epoch;
+  handler_tracking_timestamp timestamp;
 
-  boost::uint64_t current_id = 0;
+  uint64_t current_id = 0;
   if (completion* current_completion = *state->current_completion_)
     current_id = current_completion->id_;
 
   write_line(
-#if defined(BOOST_WINDOWS)
+#if defined(BOOST_ASIO_WINDOWS)
       "@asio|%I64u.%06I64u|%I64u*%I64u|%.20s@%p.%.50s\n",
-#else // defined(BOOST_WINDOWS)
+#else // defined(BOOST_ASIO_WINDOWS)
       "@asio|%llu.%06llu|%llu*%llu|%.20s@%p.%.50s\n",
-#endif // defined(BOOST_WINDOWS)
-      static_cast<boost::uint64_t>(now.total_seconds()),
-      static_cast<boost::uint64_t>(now.total_microseconds() % 1000000),
+#endif // defined(BOOST_ASIO_WINDOWS)
+      timestamp.seconds, timestamp.microseconds,
       current_id, h->id_, object_type, object, op_name);
 }
 
 handler_tracking::completion::completion(handler_tracking::tracked_handler* h)
   : id_(h->id_),
     invoked_(false),
@@ -98,197 +130,173 @@ handler_tracking::completion::completion(handler_tracking::tracked_handler* h)
 }
 
 handler_tracking::completion::~completion()
 {
   if (id_)
   {
-    boost::posix_time::ptime epoch(boost::gregorian::date(1970, 1, 1));
-    boost::posix_time::time_duration now =
-      boost::posix_time::microsec_clock::universal_time() - epoch;
+    handler_tracking_timestamp timestamp;
 
     write_line(
-#if defined(BOOST_WINDOWS)
+#if defined(BOOST_ASIO_WINDOWS)
         "@asio|%I64u.%06I64u|%c%I64u|\n",
-#else // defined(BOOST_WINDOWS)
+#else // defined(BOOST_ASIO_WINDOWS)
         "@asio|%llu.%06llu|%c%llu|\n",
-#endif // defined(BOOST_WINDOWS)
-        static_cast<boost::uint64_t>(now.total_seconds()),
-        static_cast<boost::uint64_t>(now.total_microseconds() % 1000000),
+#endif // defined(BOOST_ASIO_WINDOWS)
+        timestamp.seconds, timestamp.microseconds,
         invoked_ ? '!' : '~', id_);
   }
 
   *get_state()->current_completion_ = next_;
 }
 
 void handler_tracking::completion::invocation_begin()
 {
-  boost::posix_time::ptime epoch(boost::gregorian::date(1970, 1, 1));
-  boost::posix_time::time_duration now =
-    boost::posix_time::microsec_clock::universal_time() - epoch;
+  handler_tracking_timestamp timestamp;
 
   write_line(
-#if defined(BOOST_WINDOWS)
+#if defined(BOOST_ASIO_WINDOWS)
       "@asio|%I64u.%06I64u|>%I64u|\n",
-#else // defined(BOOST_WINDOWS)
+#else // defined(BOOST_ASIO_WINDOWS)
       "@asio|%llu.%06llu|>%llu|\n",
-#endif // defined(BOOST_WINDOWS)
-      static_cast<boost::uint64_t>(now.total_seconds()),
-      static_cast<boost::uint64_t>(now.total_microseconds() % 1000000), id_);
+#endif // defined(BOOST_ASIO_WINDOWS)
+      timestamp.seconds, timestamp.microseconds, id_);
 
   invoked_ = true;
 }
 
 void handler_tracking::completion::invocation_begin(
     const boost::system::error_code& ec)
 {
-  boost::posix_time::ptime epoch(boost::gregorian::date(1970, 1, 1));
-  boost::posix_time::time_duration now =
-    boost::posix_time::microsec_clock::universal_time() - epoch;
+  handler_tracking_timestamp timestamp;
 
   write_line(
-#if defined(BOOST_WINDOWS)
+#if defined(BOOST_ASIO_WINDOWS)
       "@asio|%I64u.%06I64u|>%I64u|ec=%.20s:%d\n",
-#else // defined(BOOST_WINDOWS)
+#else // defined(BOOST_ASIO_WINDOWS)
       "@asio|%llu.%06llu|>%llu|ec=%.20s:%d\n",
-#endif // defined(BOOST_WINDOWS)
-      static_cast<boost::uint64_t>(now.total_seconds()),
-      static_cast<boost::uint64_t>(now.total_microseconds() % 1000000),
+#endif // defined(BOOST_ASIO_WINDOWS)
+      timestamp.seconds, timestamp.microseconds,
       id_, ec.category().name(), ec.value());
 
   invoked_ = true;
 }
 
 void handler_tracking::completion::invocation_begin(
     const boost::system::error_code& ec, std::size_t bytes_transferred)
 {
-  boost::posix_time::ptime epoch(boost::gregorian::date(1970, 1, 1));
-  boost::posix_time::time_duration now =
-    boost::posix_time::microsec_clock::universal_time() - epoch;
+  handler_tracking_timestamp timestamp;
 
   write_line(
-#if defined(BOOST_WINDOWS)
+#if defined(BOOST_ASIO_WINDOWS)
       "@asio|%I64u.%06I64u|>%I64u|ec=%.20s:%d,bytes_transferred=%I64u\n",
-#else // defined(BOOST_WINDOWS)
+#else // defined(BOOST_ASIO_WINDOWS)
       "@asio|%llu.%06llu|>%llu|ec=%.20s:%d,bytes_transferred=%llu\n",
-#endif // defined(BOOST_WINDOWS)
-      static_cast<boost::uint64_t>(now.total_seconds()),
-      static_cast<boost::uint64_t>(now.total_microseconds() % 1000000),
+#endif // defined(BOOST_ASIO_WINDOWS)
+      timestamp.seconds, timestamp.microseconds,
       id_, ec.category().name(), ec.value(),
-      static_cast<boost::uint64_t>(bytes_transferred));
+      static_cast<uint64_t>(bytes_transferred));
 
   invoked_ = true;
 }
 
 void handler_tracking::completion::invocation_begin(
     const boost::system::error_code& ec, int signal_number)
 {
-  boost::posix_time::ptime epoch(boost::gregorian::date(1970, 1, 1));
-  boost::posix_time::time_duration now =
-    boost::posix_time::microsec_clock::universal_time() - epoch;
+  handler_tracking_timestamp timestamp;
 
   write_line(
-#if defined(BOOST_WINDOWS)
+#if defined(BOOST_ASIO_WINDOWS)
       "@asio|%I64u.%06I64u|>%I64u|ec=%.20s:%d,signal_number=%d\n",
-#else // defined(BOOST_WINDOWS)
+#else // defined(BOOST_ASIO_WINDOWS)
       "@asio|%llu.%06llu|>%llu|ec=%.20s:%d,signal_number=%d\n",
-#endif // defined(BOOST_WINDOWS)
-      static_cast<boost::uint64_t>(now.total_seconds()),
-      static_cast<boost::uint64_t>(now.total_microseconds() % 1000000),
+#endif // defined(BOOST_ASIO_WINDOWS)
+      timestamp.seconds, timestamp.microseconds,
       id_, ec.category().name(), ec.value(), signal_number);
 
   invoked_ = true;
 }
 
 void handler_tracking::completion::invocation_begin(
     const boost::system::error_code& ec, const char* arg)
 {
-  boost::posix_time::ptime epoch(boost::gregorian::date(1970, 1, 1));
-  boost::posix_time::time_duration now =
-    boost::posix_time::microsec_clock::universal_time() - epoch;
+  handler_tracking_timestamp timestamp;
 
   write_line(
-#if defined(BOOST_WINDOWS)
+#if defined(BOOST_ASIO_WINDOWS)
       "@asio|%I64u.%06I64u|>%I64u|ec=%.20s:%d,%.50s\n",
-#else // defined(BOOST_WINDOWS)
+#else // defined(BOOST_ASIO_WINDOWS)
       "@asio|%llu.%06llu|>%llu|ec=%.20s:%d,%.50s\n",
-#endif // defined(BOOST_WINDOWS)
-      static_cast<boost::uint64_t>(now.total_seconds()),
-      static_cast<boost::uint64_t>(now.total_microseconds() % 1000000),
+#endif // defined(BOOST_ASIO_WINDOWS)
+      timestamp.seconds, timestamp.microseconds,
       id_, ec.category().name(), ec.value(), arg);
 
   invoked_ = true;
 }
 
 void handler_tracking::completion::invocation_end()
 {
   if (id_)
   {
-    boost::posix_time::ptime epoch(boost::gregorian::date(1970, 1, 1));
-    boost::posix_time::time_duration now =
-      boost::posix_time::microsec_clock::universal_time() - epoch;
+    handler_tracking_timestamp timestamp;
 
     write_line(
-#if defined(BOOST_WINDOWS)
+#if defined(BOOST_ASIO_WINDOWS)
         "@asio|%I64u.%06I64u|<%I64u|\n",
-#else // defined(BOOST_WINDOWS)
+#else // defined(BOOST_ASIO_WINDOWS)
         "@asio|%llu.%06llu|<%llu|\n",
-#endif // defined(BOOST_WINDOWS)
-        static_cast<boost::uint64_t>(now.total_seconds()),
-        static_cast<boost::uint64_t>(now.total_microseconds() % 1000000), id_);
+#endif // defined(BOOST_ASIO_WINDOWS)
+        timestamp.seconds, timestamp.microseconds, id_);
 
     id_ = 0;
   }
 }
 
 void handler_tracking::operation(const char* object_type,
     void* object, const char* op_name)
 {
   static tracking_state* state = get_state();
 
-  boost::posix_time::ptime epoch(boost::gregorian::date(1970, 1, 1));
-  boost::posix_time::time_duration now =
-    boost::posix_time::microsec_clock::universal_time() - epoch;
+  handler_tracking_timestamp timestamp;
 
   unsigned long long current_id = 0;
   if (completion* current_completion = *state->current_completion_)
     current_id = current_completion->id_;
 
   write_line(
-#if defined(BOOST_WINDOWS)
+#if defined(BOOST_ASIO_WINDOWS)
       "@asio|%I64u.%06I64u|%I64u|%.20s@%p.%.50s\n",
-#else // defined(BOOST_WINDOWS)
+#else // defined(BOOST_ASIO_WINDOWS)
       "@asio|%llu.%06llu|%llu|%.20s@%p.%.50s\n",
-#endif // defined(BOOST_WINDOWS)
-      static_cast<boost::uint64_t>(now.total_seconds()),
-      static_cast<boost::uint64_t>(now.total_microseconds() % 1000000),
+#endif // defined(BOOST_ASIO_WINDOWS)
+      timestamp.seconds, timestamp.microseconds,
       current_id, object_type, object, op_name);
 }
 
 void handler_tracking::write_line(const char* format, ...)
 {
   using namespace std; // For sprintf (or equivalent).
 
   va_list args;
   va_start(args, format);
 
   char line[256] = "";
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) && !defined(UNDER_CE)
+#if defined(BOOST_ASIO_HAS_SECURE_RTL)
   int length = vsprintf_s(line, sizeof(line), format, args);
-#else // BOOST_WORKAROUND(BOOST_MSVC, >= 1400) && !defined(UNDER_CE)
+#else // defined(BOOST_ASIO_HAS_SECURE_RTL)
   int length = vsprintf(line, format, args);
-#endif // BOOST_WORKAROUND(BOOST_MSVC, >= 1400) && !defined(UNDER_CE)
+#endif // defined(BOOST_ASIO_HAS_SECURE_RTL)
 
   va_end(args);
 
-#if defined(BOOST_WINDOWS)
+#if defined(BOOST_ASIO_WINDOWS)
   HANDLE stderr_handle = ::GetStdHandle(STD_ERROR_HANDLE);
   DWORD bytes_written = 0;
   ::WriteFile(stderr_handle, line, length, &bytes_written, 0);
-#else // defined(BOOST_WINDOWS)
+#else // defined(BOOST_ASIO_WINDOWS)
   ::write(STDERR_FILENO, line, length);
-#endif // defined(BOOST_WINDOWS)
+#endif // defined(BOOST_ASIO_WINDOWS)
 }
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/kqueue_reactor.hpp b/3rdParty/Boost/src/boost/asio/detail/impl/kqueue_reactor.hpp
index d3445cd..889ae26 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/kqueue_reactor.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/kqueue_reactor.hpp
@@ -1,11 +1,11 @@
 //
 // detail/impl/kqueue_reactor.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) 2005 Stefan Arentz (stefan at soze 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)
 //
 
@@ -45,13 +45,13 @@ void kqueue_reactor::schedule_timer(timer_queue<Time_Traits>& queue,
     typename timer_queue<Time_Traits>::per_timer_data& timer, wait_op* op)
 {
   boost::asio::detail::mutex::scoped_lock lock(mutex_);
 
   if (shutdown_)
   {
-    io_service_.post_immediate_completion(op);
+    io_service_.post_immediate_completion(op, false);
     return;
   }
 
   bool earliest = queue.enqueue_timer(time, timer, op);
   io_service_.work_started();
   if (earliest)
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/kqueue_reactor.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/kqueue_reactor.ipp
index a819eb9..7a026a9 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/kqueue_reactor.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/kqueue_reactor.ipp
@@ -1,11 +1,11 @@
 //
 // detail/impl/kqueue_reactor.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) 2005 Stefan Arentz (stefan at soze 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)
 //
 
@@ -44,16 +44,21 @@ kqueue_reactor::kqueue_reactor(boost::asio::io_service& io_service)
     io_service_(use_service<io_service_impl>(io_service)),
     mutex_(),
     kqueue_fd_(do_kqueue_create()),
     interrupter_(),
     shutdown_(false)
 {
-  // The interrupter is put into a permanently readable state. Whenever we want
-  // to interrupt the blocked kevent call we register a read operation against
-  // the descriptor.
-  interrupter_.interrupt();
+  struct kevent event;
+  BOOST_ASIO_KQUEUE_EV_SET(&event, interrupter_.read_descriptor(),
+      EVFILT_READ, EV_ADD, 0, 0, &interrupter_);
+  if (::kevent(kqueue_fd_, &event, 1, 0, 0, 0) == -1)
+  {
+    boost::system::error_code error(errno,
+        boost::asio::error::get_system_category());
+    boost::asio::detail::throw_error(error);
+  }
 }
 
 kqueue_reactor::~kqueue_reactor()
 {
   close(kqueue_fd_);
 }
@@ -86,32 +91,33 @@ void kqueue_reactor::fork_service(boost::asio::io_service::fork_event fork_ev)
     // The kqueue descriptor is automatically closed in the child.
     kqueue_fd_ = -1;
     kqueue_fd_ = do_kqueue_create();
 
     interrupter_.recreate();
 
+    struct kevent event;
+    BOOST_ASIO_KQUEUE_EV_SET(&event, interrupter_.read_descriptor(),
+        EVFILT_READ, EV_ADD, 0, 0, &interrupter_);
+    if (::kevent(kqueue_fd_, &event, 1, 0, 0, 0) == -1)
+    {
+      boost::system::error_code error(errno,
+          boost::asio::error::get_system_category());
+      boost::asio::detail::throw_error(error);
+    }
+
     // Re-register all descriptors with kqueue.
     mutex::scoped_lock descriptors_lock(registered_descriptors_mutex_);
     for (descriptor_state* state = registered_descriptors_.first();
         state != 0; state = state->next_)
     {
       struct kevent events[2];
-      int num_events = 0;
-
-      if (!state->op_queue_[read_op].empty())
-        BOOST_ASIO_KQUEUE_EV_SET(&events[num_events++], state->descriptor_,
-            EVFILT_READ, EV_ADD | EV_CLEAR, 0, 0, state);
-      else if (!state->op_queue_[except_op].empty())
-        BOOST_ASIO_KQUEUE_EV_SET(&events[num_events++], state->descriptor_,
-            EVFILT_READ, EV_ADD | EV_CLEAR, EV_OOBAND, 0, state);
-
-      if (!state->op_queue_[write_op].empty())
-        BOOST_ASIO_KQUEUE_EV_SET(&events[num_events++], state->descriptor_,
-            EVFILT_WRITE, EV_ADD | EV_CLEAR, 0, 0, state);
-
-      if (num_events && ::kevent(kqueue_fd_, events, num_events, 0, 0, 0) == -1)
+      BOOST_ASIO_KQUEUE_EV_SET(&events[0], state->descriptor_,
+          EVFILT_READ, EV_ADD | EV_CLEAR, 0, 0, state);
+      BOOST_ASIO_KQUEUE_EV_SET(&events[1], state->descriptor_,
+          EVFILT_WRITE, EV_ADD | EV_CLEAR, 0, 0, state);
+      if (::kevent(kqueue_fd_, events, 2, 0, 0, 0) == -1)
       {
         boost::system::error_code error(errno,
             boost::asio::error::get_system_category());
         boost::asio::detail::throw_error(error);
       }
     }
@@ -130,12 +136,20 @@ int kqueue_reactor::register_descriptor(socket_type descriptor,
 
   mutex::scoped_lock lock(descriptor_data->mutex_);
 
   descriptor_data->descriptor_ = descriptor;
   descriptor_data->shutdown_ = false;
 
+  struct kevent events[2];
+  BOOST_ASIO_KQUEUE_EV_SET(&events[0], descriptor, EVFILT_READ,
+      EV_ADD | EV_CLEAR, 0, 0, descriptor_data);
+  BOOST_ASIO_KQUEUE_EV_SET(&events[1], descriptor, EVFILT_WRITE,
+      EV_ADD | EV_CLEAR, 0, 0, descriptor_data);
+  if (::kevent(kqueue_fd_, events, 2, 0, 0, 0) == -1)
+    return errno;
+
   return 0;
 }
 
 int kqueue_reactor::register_internal_descriptor(
     int op_type, socket_type descriptor,
     kqueue_reactor::per_descriptor_data& descriptor_data, reactor_op* op)
@@ -145,29 +159,19 @@ int kqueue_reactor::register_internal_descriptor(
   mutex::scoped_lock lock(descriptor_data->mutex_);
 
   descriptor_data->descriptor_ = descriptor;
   descriptor_data->shutdown_ = false;
   descriptor_data->op_queue_[op_type].push(op);
 
-  struct kevent event;
-  switch (op_type)
-  {
-  case read_op:
-    BOOST_ASIO_KQUEUE_EV_SET(&event, descriptor, EVFILT_READ,
-        EV_ADD | EV_CLEAR, 0, 0, descriptor_data);
-    break;
-  case write_op:
-    BOOST_ASIO_KQUEUE_EV_SET(&event, descriptor, EVFILT_WRITE,
-        EV_ADD | EV_CLEAR, 0, 0, descriptor_data);
-    break;
-  case except_op:
-    BOOST_ASIO_KQUEUE_EV_SET(&event, descriptor, EVFILT_READ,
-        EV_ADD | EV_CLEAR, EV_OOBAND, 0, descriptor_data);
-    break;
-  }
-  ::kevent(kqueue_fd_, &event, 1, 0, 0, 0);
+  struct kevent events[2];
+  BOOST_ASIO_KQUEUE_EV_SET(&events[0], descriptor, EVFILT_READ,
+      EV_ADD | EV_CLEAR, 0, 0, descriptor_data);
+  BOOST_ASIO_KQUEUE_EV_SET(&events[1], descriptor, EVFILT_WRITE,
+      EV_ADD | EV_CLEAR, 0, 0, descriptor_data);
+  if (::kevent(kqueue_fd_, events, 2, 0, 0, 0) == -1)
+    return errno;
 
   return 0;
 }
 
 void kqueue_reactor::move_descriptor(socket_type,
     kqueue_reactor::per_descriptor_data& target_descriptor_data,
@@ -175,79 +179,57 @@ void kqueue_reactor::move_descriptor(socket_type,
 {
   target_descriptor_data = source_descriptor_data;
   source_descriptor_data = 0;
 }
 
 void kqueue_reactor::start_op(int op_type, socket_type descriptor,
-    kqueue_reactor::per_descriptor_data& descriptor_data,
-    reactor_op* op, bool allow_speculative)
+    kqueue_reactor::per_descriptor_data& descriptor_data, reactor_op* op,
+    bool is_continuation, bool allow_speculative)
 {
   if (!descriptor_data)
   {
     op->ec_ = boost::asio::error::bad_descriptor;
-    post_immediate_completion(op);
+    post_immediate_completion(op, is_continuation);
     return;
   }
 
   mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
 
   if (descriptor_data->shutdown_)
   {
-    post_immediate_completion(op);
+    post_immediate_completion(op, is_continuation);
     return;
   }
 
   bool first = descriptor_data->op_queue_[op_type].empty();
   if (first)
   {
-    if (allow_speculative)
+    if (allow_speculative
+        && (op_type != read_op
+          || descriptor_data->op_queue_[except_op].empty()))
     {
-      if (op_type != read_op || descriptor_data->op_queue_[except_op].empty())
+      if (op->perform())
       {
-        if (op->perform())
-        {
-          descriptor_lock.unlock();
-          io_service_.post_immediate_completion(op);
-          return;
-        }
+        descriptor_lock.unlock();
+        io_service_.post_immediate_completion(op, is_continuation);
+        return;
       }
     }
-  }
-
-  descriptor_data->op_queue_[op_type].push(op);
-  io_service_.work_started();
-
-  if (first)
-  {
-    struct kevent event;
-    switch (op_type)
+    else
     {
-    case read_op:
-      BOOST_ASIO_KQUEUE_EV_SET(&event, descriptor, EVFILT_READ,
+      struct kevent events[2];
+      BOOST_ASIO_KQUEUE_EV_SET(&events[0], descriptor, EVFILT_READ,
           EV_ADD | EV_CLEAR, 0, 0, descriptor_data);
-      break;
-    case write_op:
-      BOOST_ASIO_KQUEUE_EV_SET(&event, descriptor, EVFILT_WRITE,
+      BOOST_ASIO_KQUEUE_EV_SET(&events[1], descriptor, EVFILT_WRITE,
           EV_ADD | EV_CLEAR, 0, 0, descriptor_data);
-      break;
-    case except_op:
-      if (!descriptor_data->op_queue_[read_op].empty())
-        return; // Already registered for read events.
-      BOOST_ASIO_KQUEUE_EV_SET(&event, descriptor, EVFILT_READ,
-          EV_ADD | EV_CLEAR, EV_OOBAND, 0, descriptor_data);
-      break;
-    }
-
-    if (::kevent(kqueue_fd_, &event, 1, 0, 0, 0) == -1)
-    {
-      op->ec_ = boost::system::error_code(errno,
-          boost::asio::error::get_system_category());
-      descriptor_data->op_queue_[op_type].pop();
-      io_service_.post_deferred_completion(op);
+      ::kevent(kqueue_fd_, events, 2, 0, 0, 0);
     }
   }
+
+  descriptor_data->op_queue_[op_type].push(op);
+  io_service_.work_started();
 }
 
 void kqueue_reactor::cancel_ops(socket_type,
     kqueue_reactor::per_descriptor_data& descriptor_data)
 {
   if (!descriptor_data)
@@ -364,18 +346,16 @@ void kqueue_reactor::run(bool block, op_queue<operation>& ops)
   struct kevent events[128];
   int num_events = kevent(kqueue_fd_, 0, 0, events, 128, timeout);
 
   // Dispatch the waiting events.
   for (int i = 0; i < num_events; ++i)
   {
-    int descriptor = events[i].ident;
     void* ptr = reinterpret_cast<void*>(events[i].udata);
     if (ptr == &interrupter_)
     {
-      // No need to reset the interrupter since we're leaving the descriptor
-      // in a ready-to-read state and relying on edge-triggered notifications.
+      interrupter_.reset();
     }
     else
     {
       descriptor_state* descriptor_data = static_cast<descriptor_state*>(ptr);
       mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
 
@@ -394,13 +374,14 @@ void kqueue_reactor::run(bool block, op_queue<operation>& ops)
           if (j != except_op || events[i].flags & EV_OOBAND)
           {
             while (reactor_op* op = descriptor_data->op_queue_[j].front())
             {
               if (events[i].flags & EV_ERROR)
               {
-                op->ec_ = boost::system::error_code(events[i].data,
+                op->ec_ = boost::system::error_code(
+                    static_cast<int>(events[i].data),
                     boost::asio::error::get_system_category());
                 descriptor_data->op_queue_[j].pop();
                 ops.push(op);
               }
               if (op->perform())
               {
@@ -410,64 +391,22 @@ void kqueue_reactor::run(bool block, op_queue<operation>& ops)
               else
                 break;
             }
           }
         }
       }
-
-      // Renew registration for event notifications.
-      struct kevent event;
-      switch (events[i].filter)
-      {
-      case EVFILT_READ:
-        if (!descriptor_data->op_queue_[read_op].empty())
-          BOOST_ASIO_KQUEUE_EV_SET(&event, descriptor, EVFILT_READ,
-              EV_ADD | EV_CLEAR, 0, 0, descriptor_data);
-        else if (!descriptor_data->op_queue_[except_op].empty())
-          BOOST_ASIO_KQUEUE_EV_SET(&event, descriptor, EVFILT_READ,
-              EV_ADD | EV_CLEAR, EV_OOBAND, 0, descriptor_data);
-        else
-          continue;
-        break;
-      case EVFILT_WRITE:
-        if (!descriptor_data->op_queue_[write_op].empty())
-          BOOST_ASIO_KQUEUE_EV_SET(&event, descriptor, EVFILT_WRITE,
-              EV_ADD | EV_CLEAR, 0, 0, descriptor_data);
-        else
-          continue;
-        break;
-      default:
-        break;
-      }
-      if (::kevent(kqueue_fd_, &event, 1, 0, 0, 0) == -1)
-      {
-        boost::system::error_code error(errno,
-            boost::asio::error::get_system_category());
-        for (int j = 0; j < max_ops; ++j)
-        {
-          while (reactor_op* op = descriptor_data->op_queue_[j].front())
-          {
-            op->ec_ = error;
-            descriptor_data->op_queue_[j].pop();
-            ops.push(op);
-          }
-        }
-      }
     }
   }
 
   lock.lock();
   timer_queues_.get_ready_timers(ops);
 }
 
 void kqueue_reactor::interrupt()
 {
-  struct kevent event;
-  BOOST_ASIO_KQUEUE_EV_SET(&event, interrupter_.read_descriptor(),
-      EVFILT_READ, EV_ADD | EV_CLEAR, 0, 0, &interrupter_);
-  ::kevent(kqueue_fd_, &event, 1, 0, 0, 0);
+  interrupter_.interrupt();
 }
 
 int kqueue_reactor::do_kqueue_create()
 {
   int fd = ::kqueue();
   if (fd == -1)
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/pipe_select_interrupter.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/pipe_select_interrupter.ipp
index 75a8d16..556c5a2 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/pipe_select_interrupter.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/pipe_select_interrupter.ipp
@@ -1,11 +1,11 @@
 //
 // detail/impl/pipe_select_interrupter.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_IMPL_PIPE_SELECT_INTERRUPTER_IPP
@@ -14,22 +14,24 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
-#if !defined(BOOST_WINDOWS)
+#if !defined(BOOST_ASIO_WINDOWS_RUNTIME)
+#if !defined(BOOST_ASIO_WINDOWS)
 #if !defined(__CYGWIN__)
 #if !defined(__SYMBIAN32__)
 #if !defined(BOOST_ASIO_HAS_EVENTFD)
 
 #include <fcntl.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <unistd.h>
 #include <boost/asio/detail/pipe_select_interrupter.hpp>
+#include <boost/asio/detail/socket_types.hpp>
 #include <boost/asio/detail/throw_error.hpp>
 #include <boost/asio/error.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
@@ -87,22 +89,22 @@ void pipe_select_interrupter::recreate()
   open_descriptors();
 }
 
 void pipe_select_interrupter::interrupt()
 {
   char byte = 0;
-  int result = ::write(write_descriptor_, &byte, 1);
+  signed_size_type result = ::write(write_descriptor_, &byte, 1);
   (void)result;
 }
 
 bool pipe_select_interrupter::reset()
 {
   for (;;)
   {
     char data[1024];
-    int bytes_read = ::read(read_descriptor_, data, sizeof(data));
+    signed_size_type bytes_read = ::read(read_descriptor_, data, sizeof(data));
     if (bytes_read < 0 && errno == EINTR)
       continue;
     bool was_interrupted = (bytes_read > 0);
     while (bytes_read == sizeof(data))
       bytes_read = ::read(read_descriptor_, data, sizeof(data));
     return was_interrupted;
@@ -115,9 +117,10 @@ bool pipe_select_interrupter::reset()
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // !defined(BOOST_ASIO_HAS_EVENTFD)
 #endif // !defined(__SYMBIAN32__)
 #endif // !defined(__CYGWIN__)
-#endif // !defined(BOOST_WINDOWS)
+#endif // !defined(BOOST_ASIO_WINDOWS)
+#endif // !defined(BOOST_ASIO_WINDOWS_RUNTIME)
 
 #endif // BOOST_ASIO_DETAIL_IMPL_PIPE_SELECT_INTERRUPTER_IPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/posix_event.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/posix_event.ipp
index 08eae05..acb0f57 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/posix_event.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/posix_event.ipp
@@ -1,11 +1,11 @@
 //
 // detail/impl/posix_event.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_IMPL_POSIX_EVENT_IPP
@@ -14,25 +14,26 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
-#if defined(BOOST_HAS_PTHREADS) && !defined(BOOST_ASIO_DISABLE_THREADS)
+#if defined(BOOST_ASIO_HAS_PTHREADS)
 
 #include <boost/asio/detail/posix_event.hpp>
 #include <boost/asio/detail/throw_error.hpp>
+#include <boost/asio/error.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 posix_event::posix_event()
-  : signalled_(false)
+  : state_(0)
 {
   int error = ::pthread_cond_init(&cond_, 0);
   boost::system::error_code ec(error,
       boost::asio::error::get_system_category());
   boost::asio::detail::throw_error(ec, "event");
 }
@@ -40,9 +41,9 @@ posix_event::posix_event()
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
-#endif // defined(BOOST_HAS_PTHREADS) && !defined(BOOST_ASIO_DISABLE_THREADS)
+#endif // defined(BOOST_ASIO_HAS_PTHREADS)
 
 #endif // BOOST_ASIO_DETAIL_IMPL_POSIX_EVENT_IPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/posix_mutex.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/posix_mutex.ipp
index 94b9bf4..d815512 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/posix_mutex.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/posix_mutex.ipp
@@ -1,11 +1,11 @@
 //
 // detail/impl/posix_mutex.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_IMPL_POSIX_MUTEX_IPP
@@ -14,13 +14,13 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
-#if defined(BOOST_HAS_PTHREADS) && !defined(BOOST_ASIO_DISABLE_THREADS)
+#if defined(BOOST_ASIO_HAS_PTHREADS)
 
 #include <boost/asio/detail/posix_mutex.hpp>
 #include <boost/asio/detail/throw_error.hpp>
 #include <boost/asio/error.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
@@ -40,9 +40,9 @@ posix_mutex::posix_mutex()
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
-#endif // defined(BOOST_HAS_PTHREADS) && !defined(BOOST_ASIO_DISABLE_THREADS)
+#endif // defined(BOOST_ASIO_HAS_PTHREADS)
 
 #endif // BOOST_ASIO_DETAIL_IMPL_POSIX_MUTEX_IPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/posix_thread.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/posix_thread.ipp
index 0c52971..4b487d9 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/posix_thread.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/posix_thread.ipp
@@ -1,11 +1,11 @@
 //
 // detail/impl/posix_thread.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_IMPL_POSIX_THREAD_IPP
@@ -14,13 +14,13 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
-#if defined(BOOST_HAS_PTHREADS) && !defined(BOOST_ASIO_DISABLE_THREADS)
+#if defined(BOOST_ASIO_HAS_PTHREADS)
 
 #include <boost/asio/detail/posix_thread.hpp>
 #include <boost/asio/detail/throw_error.hpp>
 #include <boost/asio/error.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
@@ -68,9 +68,9 @@ void* boost_asio_detail_posix_thread_function(void* arg)
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
-#endif // defined(BOOST_HAS_PTHREADS) && !defined(BOOST_ASIO_DISABLE_THREADS)
+#endif // defined(BOOST_ASIO_HAS_PTHREADS)
 
 #endif // BOOST_ASIO_DETAIL_IMPL_POSIX_THREAD_IPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/posix_tss_ptr.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/posix_tss_ptr.ipp
index 5124c5f..65f9077 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/posix_tss_ptr.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/posix_tss_ptr.ipp
@@ -1,11 +1,11 @@
 //
 // detail/impl/posix_tss_ptr.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_IMPL_POSIX_TSS_PTR_IPP
@@ -14,13 +14,13 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
-#if defined(BOOST_HAS_PTHREADS) && !defined(BOOST_ASIO_DISABLE_THREADS)
+#if defined(BOOST_ASIO_HAS_PTHREADS)
 
 #include <boost/asio/detail/posix_tss_ptr.hpp>
 #include <boost/asio/detail/throw_error.hpp>
 #include <boost/asio/error.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
@@ -40,9 +40,9 @@ void posix_tss_ptr_create(pthread_key_t& key)
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
-#endif // defined(BOOST_HAS_PTHREADS) && !defined(BOOST_ASIO_DISABLE_THREADS)
+#endif // defined(BOOST_ASIO_HAS_PTHREADS)
 
 #endif // BOOST_ASIO_DETAIL_IMPL_POSIX_TSS_PTR_IPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/reactive_descriptor_service.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/reactive_descriptor_service.ipp
index dff0a82..abf4c6f 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/reactive_descriptor_service.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/reactive_descriptor_service.ipp
@@ -1,11 +1,11 @@
 //
 // detail/impl/reactive_descriptor_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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_IMPL_REACTIVE_DESCRIPTOR_SERVICE_IPP
@@ -14,13 +14,15 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
-#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+#if !defined(BOOST_ASIO_WINDOWS) \
+  && !defined(BOOST_ASIO_WINDOWS_RUNTIME) \
+  && !defined(__CYGWIN__)
 
 #include <boost/asio/error.hpp>
 #include <boost/asio/detail/reactive_descriptor_service.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
@@ -174,32 +176,35 @@ boost::system::error_code reactive_descriptor_service::cancel(
   ec = boost::system::error_code();
   return ec;
 }
 
 void reactive_descriptor_service::start_op(
     reactive_descriptor_service::implementation_type& impl,
-    int op_type, reactor_op* op, bool is_non_blocking, bool noop)
+    int op_type, reactor_op* op, bool is_continuation,
+    bool is_non_blocking, bool noop)
 {
   if (!noop)
   {
     if ((impl.state_ & descriptor_ops::non_blocking) ||
         descriptor_ops::set_internal_non_blocking(
           impl.descriptor_, impl.state_, true, op->ec_))
     {
       reactor_.start_op(op_type, impl.descriptor_,
-          impl.reactor_data_, op, is_non_blocking);
+          impl.reactor_data_, op, is_continuation, is_non_blocking);
       return;
     }
   }
 
-  reactor_.post_immediate_completion(op);
+  reactor_.post_immediate_completion(op, is_continuation);
 }
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
-#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+#endif // !defined(BOOST_ASIO_WINDOWS)
+       //   && !defined(BOOST_ASIO_WINDOWS_RUNTIME)
+       //   && !defined(__CYGWIN__)
 
 #endif // BOOST_ASIO_DETAIL_IMPL_REACTIVE_DESCRIPTOR_SERVICE_IPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/reactive_serial_port_service.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/reactive_serial_port_service.ipp
index 0f530d7..b8c2f4a 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/reactive_serial_port_service.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/reactive_serial_port_service.ipp
@@ -1,11 +1,11 @@
 //
 // detail/impl/reactive_serial_port_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)
 // Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.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,13 +16,13 @@
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
 #if defined(BOOST_ASIO_HAS_SERIAL_PORT)
-#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+#if !defined(BOOST_ASIO_WINDOWS) && !defined(__CYGWIN__)
 
 #include <cstring>
 #include <boost/asio/detail/reactive_serial_port_service.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
@@ -144,10 +144,10 @@ boost::system::error_code reactive_serial_port_service::do_get_option(
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
-#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+#endif // !defined(BOOST_ASIO_WINDOWS) && !defined(__CYGWIN__)
 #endif // defined(BOOST_ASIO_HAS_SERIAL_PORT)
 
 #endif // BOOST_ASIO_DETAIL_IMPL_REACTIVE_SERIAL_PORT_SERVICE_IPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/reactive_socket_service_base.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/reactive_socket_service_base.ipp
index 93277e0..c72871d 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/reactive_socket_service_base.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/reactive_socket_service_base.ipp
@@ -1,11 +1,11 @@
 //
 // detail/reactive_socket_service_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)
 //
 // 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_DETAIL_IMPL_REACTIVE_SOCKET_SERVICE_BASE_IPP
@@ -14,13 +14,14 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
-#if !defined(BOOST_ASIO_HAS_IOCP)
+#if !defined(BOOST_ASIO_HAS_IOCP) \
+  && !defined(BOOST_ASIO_WINDOWS_RUNTIME)
 
 #include <boost/asio/detail/reactive_socket_service_base.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
@@ -197,69 +198,72 @@ boost::system::error_code reactive_socket_service_base::do_assign(
   ec = boost::system::error_code();
   return ec;
 }
 
 void reactive_socket_service_base::start_op(
     reactive_socket_service_base::base_implementation_type& impl,
-    int op_type, reactor_op* op, bool is_non_blocking, bool noop)
+    int op_type, reactor_op* op, bool is_continuation,
+    bool is_non_blocking, bool noop)
 {
   if (!noop)
   {
     if ((impl.state_ & socket_ops::non_blocking)
         || socket_ops::set_internal_non_blocking(
           impl.socket_, impl.state_, true, op->ec_))
     {
       reactor_.start_op(op_type, impl.socket_,
-          impl.reactor_data_, op, is_non_blocking);
+          impl.reactor_data_, op, is_continuation, is_non_blocking);
       return;
     }
   }
 
-  reactor_.post_immediate_completion(op);
+  reactor_.post_immediate_completion(op, is_continuation);
 }
 
 void reactive_socket_service_base::start_accept_op(
     reactive_socket_service_base::base_implementation_type& impl,
-    reactor_op* op, bool peer_is_open)
+    reactor_op* op, bool is_continuation, bool peer_is_open)
 {
   if (!peer_is_open)
-    start_op(impl, reactor::read_op, op, true, false);
+    start_op(impl, reactor::read_op, op, true, is_continuation, false);
   else
   {
     op->ec_ = boost::asio::error::already_open;
-    reactor_.post_immediate_completion(op);
+    reactor_.post_immediate_completion(op, is_continuation);
   }
 }
 
 void reactive_socket_service_base::start_connect_op(
     reactive_socket_service_base::base_implementation_type& impl,
-    reactor_op* op, const socket_addr_type* addr, size_t addrlen)
+    reactor_op* op, bool is_continuation,
+    const socket_addr_type* addr, size_t addrlen)
 {
   if ((impl.state_ & socket_ops::non_blocking)
       || socket_ops::set_internal_non_blocking(
         impl.socket_, impl.state_, true, op->ec_))
   {
     if (socket_ops::connect(impl.socket_, addr, addrlen, op->ec_) != 0)
     {
       if (op->ec_ == boost::asio::error::in_progress
           || op->ec_ == boost::asio::error::would_block)
       {
         op->ec_ = boost::system::error_code();
-        reactor_.start_op(reactor::connect_op,
-            impl.socket_, impl.reactor_data_, op, false);
+        reactor_.start_op(reactor::connect_op, impl.socket_,
+            impl.reactor_data_, op, is_continuation, false);
         return;
       }
     }
   }
 
-  reactor_.post_immediate_completion(op);
+  reactor_.post_immediate_completion(op, is_continuation);
 }
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // !defined(BOOST_ASIO_HAS_IOCP)
+       //   && !defined(BOOST_ASIO_WINDOWS_RUNTIME)
 
 #endif // BOOST_ASIO_DETAIL_IMPL_REACTIVE_SOCKET_SERVICE_BASE_IPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/resolver_service_base.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/resolver_service_base.ipp
index 6a384e4..77b6c27 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/resolver_service_base.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/resolver_service_base.ipp
@@ -1,11 +1,11 @@
 //
 // detail/impl/resolver_service_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)
 //
 // 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_DETAIL_IMPL_RESOLVER_SERVICE_BASE_IPP
@@ -107,13 +107,13 @@ void resolver_service_base::cancel(
 }
 
 void resolver_service_base::start_resolve_op(operation* op)
 {
   start_work_thread();
   io_service_impl_.work_started();
-  work_io_service_impl_.post_immediate_completion(op);
+  work_io_service_impl_.post_immediate_completion(op, false);
 }
 
 void resolver_service_base::start_work_thread()
 {
   boost::asio::detail::mutex::scoped_lock lock(mutex_);
   if (!work_thread_.get())
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/select_reactor.hpp b/3rdParty/Boost/src/boost/asio/detail/impl/select_reactor.hpp
index 0d4097e..f2b79f7 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/select_reactor.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/select_reactor.hpp
@@ -1,11 +1,11 @@
 //
 // detail/impl/select_reactor.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_IMPL_SELECT_REACTOR_HPP
@@ -17,13 +17,14 @@
 
 #include <boost/asio/detail/config.hpp>
 
 #if defined(BOOST_ASIO_HAS_IOCP) \
   || (!defined(BOOST_ASIO_HAS_DEV_POLL) \
       && !defined(BOOST_ASIO_HAS_EPOLL) \
-      && !defined(BOOST_ASIO_HAS_KQUEUE))
+      && !defined(BOOST_ASIO_HAS_KQUEUE) \
+      && !defined(BOOST_ASIO_WINDOWS_RUNTIME))
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
@@ -47,13 +48,13 @@ void select_reactor::schedule_timer(timer_queue<Time_Traits>& queue,
     typename timer_queue<Time_Traits>::per_timer_data& timer, wait_op* op)
 {
   boost::asio::detail::mutex::scoped_lock lock(mutex_);
 
   if (shutdown_)
   {
-    io_service_.post_immediate_completion(op);
+    io_service_.post_immediate_completion(op, false);
     return;
   }
 
   bool earliest = queue.enqueue_timer(time, timer, op);
   io_service_.work_started();
   if (earliest)
@@ -79,9 +80,10 @@ std::size_t select_reactor::cancel_timer(timer_queue<Time_Traits>& queue,
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // defined(BOOST_ASIO_HAS_IOCP)
        //   || (!defined(BOOST_ASIO_HAS_DEV_POLL)
        //       && !defined(BOOST_ASIO_HAS_EPOLL)
-       //       && !defined(BOOST_ASIO_HAS_KQUEUE))
+       //       && !defined(BOOST_ASIO_HAS_KQUEUE)
+       //       && !defined(BOOST_ASIO_WINDOWS_RUNTIME))
 
 #endif // BOOST_ASIO_DETAIL_IMPL_SELECT_REACTOR_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/select_reactor.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/select_reactor.ipp
index d11904e..c8e04a2 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/select_reactor.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/select_reactor.ipp
@@ -1,11 +1,11 @@
 //
 // detail/impl/select_reactor.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_IMPL_SELECT_REACTOR_IPP
@@ -17,13 +17,14 @@
 
 #include <boost/asio/detail/config.hpp>
 
 #if defined(BOOST_ASIO_HAS_IOCP) \
   || (!defined(BOOST_ASIO_HAS_DEV_POLL) \
       && !defined(BOOST_ASIO_HAS_EPOLL) \
-      && !defined(BOOST_ASIO_HAS_KQUEUE))
+      && !defined(BOOST_ASIO_HAS_KQUEUE) \
+      && !defined(BOOST_ASIO_WINDOWS_RUNTIME))
 
 #include <boost/asio/detail/bind_handler.hpp>
 #include <boost/asio/detail/fd_set_adapter.hpp>
 #include <boost/asio/detail/select_reactor.hpp>
 #include <boost/asio/detail/signal_blocker.hpp>
 #include <boost/asio/detail/socket_ops.hpp>
@@ -119,19 +120,20 @@ void select_reactor::move_descriptor(socket_type,
     select_reactor::per_descriptor_data&,
     select_reactor::per_descriptor_data&)
 {
 }
 
 void select_reactor::start_op(int op_type, socket_type descriptor,
-    select_reactor::per_descriptor_data&, reactor_op* op, bool)
+    select_reactor::per_descriptor_data&, reactor_op* op,
+    bool is_continuation, bool)
 {
   boost::asio::detail::mutex::scoped_lock lock(mutex_);
 
   if (shutdown_)
   {
-    post_immediate_completion(op);
+    post_immediate_completion(op, is_continuation);
     return;
   }
 
   bool first = op_queue_[op_type].enqueue_operation(descriptor, op);
   io_service_.work_started();
   if (first)
@@ -177,27 +179,27 @@ void select_reactor::run(bool block, op_queue<operation>& ops)
   fd_sets_[read_op].set(interrupter_.read_descriptor());
   socket_type max_fd = 0;
   bool have_work_to_do = !timer_queues_.all_empty();
   for (int i = 0; i < max_select_ops; ++i)
   {
     have_work_to_do = have_work_to_do || !op_queue_[i].empty();
-    op_queue_[i].get_descriptors(fd_sets_[i], ops);
+    fd_sets_[i].set(op_queue_[i], ops);
     if (fd_sets_[i].max_descriptor() > max_fd)
       max_fd = fd_sets_[i].max_descriptor();
   }
 
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   // Connection operations on Windows use both except and write fd_sets.
   have_work_to_do = have_work_to_do || !op_queue_[connect_op].empty();
-  op_queue_[connect_op].get_descriptors(fd_sets_[write_op], ops);
+  fd_sets_[write_op].set(op_queue_[connect_op], ops);
   if (fd_sets_[write_op].max_descriptor() > max_fd)
     max_fd = fd_sets_[write_op].max_descriptor();
-  op_queue_[connect_op].get_descriptors(fd_sets_[except_op], ops);
+  fd_sets_[except_op].set(op_queue_[connect_op], ops);
   if (fd_sets_[except_op].max_descriptor() > max_fd)
     max_fd = fd_sets_[except_op].max_descriptor();
-#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 
   // We can return immediately if there's no work to do and the reactor is
   // not supposed to block.
   if (!block && !have_work_to_do)
     return;
 
@@ -221,24 +223,22 @@ void select_reactor::run(bool block, op_queue<operation>& ops)
 
   lock.lock();
 
   // Dispatch all ready operations.
   if (retval > 0)
   {
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
     // Connection operations on Windows use both except and write fd_sets.
-    op_queue_[connect_op].perform_operations_for_descriptors(
-        fd_sets_[except_op], ops);
-    op_queue_[connect_op].perform_operations_for_descriptors(
-        fd_sets_[write_op], ops);
-#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+    fd_sets_[except_op].perform(op_queue_[connect_op], ops);
+    fd_sets_[write_op].perform(op_queue_[connect_op], ops);
+#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 
     // Exception operations must be processed first to ensure that any
     // out-of-band data is read before normal data.
     for (int i = max_select_ops - 1; i >= 0; --i)
-      op_queue_[i].perform_operations_for_descriptors(fd_sets_[i], ops);
+      fd_sets_[i].perform(op_queue_[i], ops);
   }
   timer_queues_.get_ready_timers(ops);
 }
 
 void select_reactor::interrupt()
 {
@@ -307,8 +307,9 @@ void select_reactor::cancel_ops_unlocked(socket_type descriptor,
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // defined(BOOST_ASIO_HAS_IOCP)
        //   || (!defined(BOOST_ASIO_HAS_DEV_POLL)
        //       && !defined(BOOST_ASIO_HAS_EPOLL)
        //       && !defined(BOOST_ASIO_HAS_KQUEUE))
+       //       && !defined(BOOST_ASIO_WINDOWS_RUNTIME))
 
 #endif // BOOST_ASIO_DETAIL_IMPL_SELECT_REACTOR_IPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/service_registry.hpp b/3rdParty/Boost/src/boost/asio/detail/impl/service_registry.hpp
index eef25ac..1f71f08 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/service_registry.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/service_registry.hpp
@@ -1,11 +1,11 @@
 //
 // detail/impl/service_registry.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_IMPL_SERVICE_REGISTRY_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/service_registry.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/service_registry.ipp
index 6715010..adfcaa0 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/service_registry.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/service_registry.ipp
@@ -1,11 +1,11 @@
 //
 // detail/impl/service_registry.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_IMPL_SERVICE_REGISTRY_IPP
@@ -13,15 +13,15 @@
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
-#include <boost/throw_exception.hpp>
 #include <vector>
 #include <boost/asio/detail/service_registry.hpp>
+#include <boost/asio/detail/throw_exception.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
@@ -143,22 +143,22 @@ boost::asio::io_service::service* service_registry::do_use_service(
 
 void service_registry::do_add_service(
     const boost::asio::io_service::service::key& key,
     boost::asio::io_service::service* new_service)
 {
   if (&owner_ != &new_service->get_io_service())
-    boost::throw_exception(invalid_service_owner());
+    boost::asio::detail::throw_exception(invalid_service_owner());
 
   boost::asio::detail::mutex::scoped_lock lock(mutex_);
 
   // Check if there is an existing service object with the given key.
   boost::asio::io_service::service* service = first_service_;
   while (service)
   {
     if (keys_match(service->key_, key))
-      boost::throw_exception(service_already_exists());
+      boost::asio::detail::throw_exception(service_already_exists());
     service = service->next_;
   }
 
   // Take ownership of the service object.
   new_service->key_ = key;
   new_service->next_ = first_service_;
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/signal_set_service.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/signal_set_service.ipp
index 0b57007..21be62f 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/signal_set_service.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/signal_set_service.ipp
@@ -1,11 +1,11 @@
 //
 // detail/impl/signal_set_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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_IMPL_SIGNAL_SET_SERVICE_IPP
@@ -54,31 +54,39 @@ signal_state* get_signal_state()
 {
   static signal_state state = {
     BOOST_ASIO_STATIC_MUTEX_INIT, -1, -1, false, 0, { 0 } };
   return &state;
 }
 
-void asio_signal_handler(int signal_number)
+void boost_asio_signal_handler(int signal_number)
 {
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#if defined(BOOST_ASIO_WINDOWS) \
+  || defined(BOOST_ASIO_WINDOWS_RUNTIME) \
+  || defined(__CYGWIN__)
   signal_set_service::deliver_signal(signal_number);
-#else // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#else // defined(BOOST_ASIO_WINDOWS)
+      //   || defined(BOOST_ASIO_WINDOWS_RUNTIME)
+      //   || defined(__CYGWIN__)
   int saved_errno = errno;
   signal_state* state = get_signal_state();
-  int result = ::write(state->write_descriptor_,
+  signed_size_type result = ::write(state->write_descriptor_,
       &signal_number, sizeof(signal_number));
   (void)result;
   errno = saved_errno;
-#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#endif // defined(BOOST_ASIO_WINDOWS)
+       //   || defined(BOOST_ASIO_WINDOWS_RUNTIME)
+       //   || defined(__CYGWIN__)
 
 #if defined(BOOST_ASIO_HAS_SIGNAL) && !defined(BOOST_ASIO_HAS_SIGACTION)
-  ::signal(signal_number, asio_signal_handler);
+  ::signal(signal_number, boost_asio_signal_handler);
 #endif // defined(BOOST_ASIO_HAS_SIGNAL) && !defined(BOOST_ASIO_HAS_SIGACTION)
 }
 
-#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+#if !defined(BOOST_ASIO_WINDOWS) \
+  && !defined(BOOST_ASIO_WINDOWS_RUNTIME) \
+  && !defined(__CYGWIN__)
 class signal_set_service::pipe_read_op : public reactor_op
 {
 public:
   pipe_read_op()
     : reactor_op(&pipe_read_op::do_perform, pipe_read_op::do_complete)
   {
@@ -102,28 +110,38 @@ public:
       std::size_t /*bytes_transferred*/)
   {
     pipe_read_op* o(static_cast<pipe_read_op*>(base));
     delete o;
   }
 };
-#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+#endif // !defined(BOOST_ASIO_WINDOWS)
+       //   && !defined(BOOST_ASIO_WINDOWS_RUNTIME)
+       //   && !defined(__CYGWIN__)
 
 signal_set_service::signal_set_service(
     boost::asio::io_service& io_service)
   : io_service_(boost::asio::use_service<io_service_impl>(io_service)),
-#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+#if !defined(BOOST_ASIO_WINDOWS) \
+  && !defined(BOOST_ASIO_WINDOWS_RUNTIME) \
+  && !defined(__CYGWIN__)
     reactor_(boost::asio::use_service<reactor>(io_service)),
-#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+#endif // !defined(BOOST_ASIO_WINDOWS)
+       //   && !defined(BOOST_ASIO_WINDOWS_RUNTIME)
+       //   && !defined(__CYGWIN__)
     next_(0),
     prev_(0)
 {
   get_signal_state()->mutex_.init();
 
-#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+#if !defined(BOOST_ASIO_WINDOWS) \
+  && !defined(BOOST_ASIO_WINDOWS_RUNTIME) \
+  && !defined(__CYGWIN__)
   reactor_.init_task();
-#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+#endif // !defined(BOOST_ASIO_WINDOWS)
+       //   && !defined(BOOST_ASIO_WINDOWS_RUNTIME)
+       //   && !defined(__CYGWIN__)
 
   for (int i = 0; i < max_signal_number; ++i)
     registrations_[i] = 0;
 
   add_service(this);
 }
@@ -152,45 +170,61 @@ void signal_set_service::shutdown_service()
   io_service_.abandon_operations(ops);
 }
 
 void signal_set_service::fork_service(
     boost::asio::io_service::fork_event fork_ev)
 {
-#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+#if !defined(BOOST_ASIO_WINDOWS) \
+  && !defined(BOOST_ASIO_WINDOWS_RUNTIME) \
+  && !defined(__CYGWIN__)
   signal_state* state = get_signal_state();
   static_mutex::scoped_lock lock(state->mutex_);
 
   switch (fork_ev)
   {
   case boost::asio::io_service::fork_prepare:
-    reactor_.deregister_internal_descriptor(
-        state->read_descriptor_, reactor_data_);
-    state->fork_prepared_ = true;
+    {
+      int read_descriptor = state->read_descriptor_;
+      state->fork_prepared_ = true;
+      lock.unlock();
+      reactor_.deregister_internal_descriptor(read_descriptor, reactor_data_);
+    }
     break;
   case boost::asio::io_service::fork_parent:
-    state->fork_prepared_ = false;
-    reactor_.register_internal_descriptor(reactor::read_op,
-        state->read_descriptor_, reactor_data_, new pipe_read_op);
+    if (state->fork_prepared_)
+    {
+      int read_descriptor = state->read_descriptor_;
+      state->fork_prepared_ = false;
+      lock.unlock();
+      reactor_.register_internal_descriptor(reactor::read_op,
+          read_descriptor, reactor_data_, new pipe_read_op);
+    }
     break;
   case boost::asio::io_service::fork_child:
     if (state->fork_prepared_)
     {
       boost::asio::detail::signal_blocker blocker;
       close_descriptors();
       open_descriptors();
+      int read_descriptor = state->read_descriptor_;
       state->fork_prepared_ = false;
+      lock.unlock();
+      reactor_.register_internal_descriptor(reactor::read_op,
+          read_descriptor, reactor_data_, new pipe_read_op);
     }
-    reactor_.register_internal_descriptor(reactor::read_op,
-        state->read_descriptor_, reactor_data_, new pipe_read_op);
     break;
   default:
     break;
   }
-#else // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+#else // !defined(BOOST_ASIO_WINDOWS)
+      //   && !defined(BOOST_ASIO_WINDOWS_RUNTIME)
+      //   && !defined(__CYGWIN__)
   (void)fork_ev;
-#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+#endif // !defined(BOOST_ASIO_WINDOWS)
+       //   && !defined(BOOST_ASIO_WINDOWS_RUNTIME)
+       //   && !defined(__CYGWIN__)
 }
 
 void signal_set_service::construct(
     signal_set_service::implementation_type& impl)
 {
   impl.signals_ = 0;
@@ -206,13 +240,13 @@ void signal_set_service::destroy(
 
 boost::system::error_code signal_set_service::add(
     signal_set_service::implementation_type& impl,
     int signal_number, boost::system::error_code& ec)
 {
   // Check that the signal number is valid.
-  if (signal_number < 0 || signal_number > max_signal_number)
+  if (signal_number < 0 || signal_number >= max_signal_number)
   {
     ec = boost::asio::error::invalid_argument;
     return ec;
   }
 
   signal_state* state = get_signal_state();
@@ -237,25 +271,25 @@ boost::system::error_code signal_set_service::add(
     if (state->registration_count_[signal_number] == 0)
     {
 # if defined(BOOST_ASIO_HAS_SIGACTION)
       using namespace std; // For memset.
       struct sigaction sa;
       memset(&sa, 0, sizeof(sa));
-      sa.sa_handler = asio_signal_handler;
+      sa.sa_handler = boost_asio_signal_handler;
       sigfillset(&sa.sa_mask);
       if (::sigaction(signal_number, &sa, 0) == -1)
 # else // defined(BOOST_ASIO_HAS_SIGACTION)
-      if (::signal(signal_number, asio_signal_handler) == SIG_ERR)
+      if (::signal(signal_number, boost_asio_signal_handler) == SIG_ERR)
 # endif // defined(BOOST_ASIO_HAS_SIGACTION)
       {
-# if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+# if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
         ec = boost::asio::error::invalid_argument;
-# else // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+# else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
         ec = boost::system::error_code(errno,
             boost::asio::error::get_system_category());
-# endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+# endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
         delete new_registration;
         return ec;
       }
     }
 #endif // defined(BOOST_ASIO_HAS_SIGNAL) || defined(BOOST_ASIO_HAS_SIGACTION)
 
@@ -280,13 +314,13 @@ boost::system::error_code signal_set_service::add(
 
 boost::system::error_code signal_set_service::remove(
     signal_set_service::implementation_type& impl,
     int signal_number, boost::system::error_code& ec)
 {
   // Check that the signal number is valid.
-  if (signal_number < 0 || signal_number > max_signal_number)
+  if (signal_number < 0 || signal_number >= max_signal_number)
   {
     ec = boost::asio::error::invalid_argument;
     return ec;
   }
 
   signal_state* state = get_signal_state();
@@ -314,18 +348,18 @@ boost::system::error_code signal_set_service::remove(
       sa.sa_handler = SIG_DFL;
       if (::sigaction(signal_number, &sa, 0) == -1)
 # else // defined(BOOST_ASIO_HAS_SIGACTION)
       if (::signal(signal_number, SIG_DFL) == SIG_ERR)
 # endif // defined(BOOST_ASIO_HAS_SIGACTION)
       {
-# if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+# if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
         ec = boost::asio::error::invalid_argument;
-# else // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+# else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
         ec = boost::system::error_code(errno,
             boost::asio::error::get_system_category());
-# endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+# endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
         return ec;
       }
     }
 #endif // defined(BOOST_ASIO_HAS_SIGNAL) || defined(BOOST_ASIO_HAS_SIGACTION)
 
     // Remove the registration from the set.
@@ -368,18 +402,18 @@ boost::system::error_code signal_set_service::clear(
       sa.sa_handler = SIG_DFL;
       if (::sigaction(reg->signal_number_, &sa, 0) == -1)
 # else // defined(BOOST_ASIO_HAS_SIGACTION)
       if (::signal(reg->signal_number_, SIG_DFL) == SIG_ERR)
 # endif // defined(BOOST_ASIO_HAS_SIGACTION)
       {
-# if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+# if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
         ec = boost::asio::error::invalid_argument;
-# else // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+# else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
         ec = boost::system::error_code(errno,
             boost::asio::error::get_system_category());
-# endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+# endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
         return ec;
       }
     }
 #endif // defined(BOOST_ASIO_HAS_SIGNAL) || defined(BOOST_ASIO_HAS_SIGACTION)
 
     // Remove the registration from the registration table.
@@ -463,66 +497,81 @@ void signal_set_service::deliver_signal(int signal_number)
 
 void signal_set_service::add_service(signal_set_service* service)
 {
   signal_state* state = get_signal_state();
   static_mutex::scoped_lock lock(state->mutex_);
 
-#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+#if !defined(BOOST_ASIO_WINDOWS) && !defined(__CYGWIN__)
   // If this is the first service to be created, open a new pipe.
   if (state->service_list_ == 0)
     open_descriptors();
-#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+#endif // !defined(BOOST_ASIO_WINDOWS) && !defined(__CYGWIN__)
 
   // Insert service into linked list of all services.
   service->next_ = state->service_list_;
   service->prev_ = 0;
   if (state->service_list_)
     state->service_list_->prev_ = service;
   state->service_list_ = service;
 
-#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+#if !defined(BOOST_ASIO_WINDOWS) \
+  && !defined(BOOST_ASIO_WINDOWS_RUNTIME) \
+  && !defined(__CYGWIN__)
   // Register for pipe readiness notifications.
+  int read_descriptor = state->read_descriptor_;
+  lock.unlock();
   service->reactor_.register_internal_descriptor(reactor::read_op,
-      state->read_descriptor_, service->reactor_data_, new pipe_read_op);
-#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+      read_descriptor, service->reactor_data_, new pipe_read_op);
+#endif // !defined(BOOST_ASIO_WINDOWS)
+       //   && !defined(BOOST_ASIO_WINDOWS_RUNTIME)
+       //   && !defined(__CYGWIN__)
 }
 
 void signal_set_service::remove_service(signal_set_service* service)
 {
   signal_state* state = get_signal_state();
   static_mutex::scoped_lock lock(state->mutex_);
 
   if (service->next_ || service->prev_ || state->service_list_ == service)
   {
-#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+#if !defined(BOOST_ASIO_WINDOWS) \
+  && !defined(BOOST_ASIO_WINDOWS_RUNTIME) \
+  && !defined(__CYGWIN__)
     // Disable the pipe readiness notifications.
+    int read_descriptor = state->read_descriptor_;
+    lock.unlock();
     service->reactor_.deregister_descriptor(
-        state->read_descriptor_, service->reactor_data_, false);
-#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+        read_descriptor, service->reactor_data_, false);
+    lock.lock();
+#endif // !defined(BOOST_ASIO_WINDOWS)
+       //   && !defined(BOOST_ASIO_WINDOWS_RUNTIME)
+       //   && !defined(__CYGWIN__)
 
     // Remove service from linked list of all services.
     if (state->service_list_ == service)
       state->service_list_ = service->next_;
     if (service->prev_)
       service->prev_->next_ = service->next_;
     if (service->next_)
       service->next_->prev_= service->prev_;
     service->next_ = 0;
     service->prev_ = 0;
 
-#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+#if !defined(BOOST_ASIO_WINDOWS) && !defined(__CYGWIN__)
     // If this is the last service to be removed, close the pipe.
     if (state->service_list_ == 0)
       close_descriptors();
-#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+#endif // !defined(BOOST_ASIO_WINDOWS) && !defined(__CYGWIN__)
   }
 }
 
 void signal_set_service::open_descriptors()
 {
-#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+#if !defined(BOOST_ASIO_WINDOWS) \
+  && !defined(BOOST_ASIO_WINDOWS_RUNTIME) \
+  && !defined(__CYGWIN__)
   signal_state* state = get_signal_state();
 
   int pipe_fds[2];
   if (::pipe(pipe_fds) == 0)
   {
     state->read_descriptor_ = pipe_fds[0];
@@ -539,28 +588,34 @@ void signal_set_service::open_descriptors()
   else
   {
     boost::system::error_code ec(errno,
         boost::asio::error::get_system_category());
     boost::asio::detail::throw_error(ec, "signal_set_service pipe");
   }
-#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+#endif // !defined(BOOST_ASIO_WINDOWS)
+       //   && !defined(BOOST_ASIO_WINDOWS_RUNTIME)
+       //   && !defined(__CYGWIN__)
 }
 
 void signal_set_service::close_descriptors()
 {
-#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+#if !defined(BOOST_ASIO_WINDOWS) \
+  && !defined(BOOST_ASIO_WINDOWS_RUNTIME) \
+  && !defined(__CYGWIN__)
   signal_state* state = get_signal_state();
 
   if (state->read_descriptor_ != -1)
     ::close(state->read_descriptor_);
   state->read_descriptor_ = -1;
 
   if (state->write_descriptor_ != -1)
     ::close(state->write_descriptor_);
   state->write_descriptor_ = -1;
-#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+#endif // !defined(BOOST_ASIO_WINDOWS)
+       //   && !defined(BOOST_ASIO_WINDOWS_RUNTIME)
+       //   && !defined(__CYGWIN__)
 }
 
 void signal_set_service::start_wait_op(
     signal_set_service::implementation_type& impl, signal_op* op)
 {
   io_service_.work_started();
@@ -571,12 +626,13 @@ void signal_set_service::start_wait_op(
   registration* reg = impl.signals_;
   while (reg)
   {
     if (reg->undelivered_ > 0)
     {
       --reg->undelivered_;
+      op->signal_number_ = reg->signal_number_;
       io_service_.post_deferred_completion(op);
       return;
     }
 
     reg = reg->next_in_set_;
   }
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/socket_ops.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/socket_ops.ipp
index 16e9536..f2c9a11 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/socket_ops.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/socket_ops.ipp
@@ -1,11 +1,11 @@
 //
 // detail/impl/socket_ops.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_SOCKET_OPS_IPP
@@ -13,55 +13,75 @@
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
-#include <boost/assert.hpp>
-#include <boost/detail/workaround.hpp>
+
 #include <cctype>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
 #include <cerrno>
 #include <new>
+#include <boost/asio/detail/assert.hpp>
 #include <boost/asio/detail/socket_ops.hpp>
 #include <boost/asio/error.hpp>
 
+#if defined(BOOST_ASIO_WINDOWS_RUNTIME)
+# include <codecvt>
+# include <locale>
+# include <string>
+#endif // defined(BOOST_ASIO_WINDOWS_RUNTIME)
+
+#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) \
+  || defined(__MACH__) && defined(__APPLE__)
+# if defined(BOOST_ASIO_HAS_PTHREADS)
+#  include <pthread.h>
+# endif // defined(BOOST_ASIO_HAS_PTHREADS)
+#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
+       // || defined(__MACH__) && defined(__APPLE__)
+
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 namespace socket_ops {
 
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#if !defined(BOOST_ASIO_WINDOWS_RUNTIME)
+
+#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 struct msghdr { int msg_namelen; };
-#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 
 #if defined(__hpux)
 // HP-UX doesn't declare these functions extern "C", so they are declared again
 // here to avoid linker errors about undefined symbols.
 extern "C" char* if_indextoname(unsigned int, char*);
 extern "C" unsigned int if_nametoindex(const char*);
 #endif // defined(__hpux)
 
+#endif // !defined(BOOST_ASIO_WINDOWS_RUNTIME)
+
 inline void clear_last_error()
 {
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   WSASetLastError(0);
 #else
   errno = 0;
 #endif
 }
 
+#if !defined(BOOST_ASIO_WINDOWS_RUNTIME)
+
 template <typename ReturnType>
 inline ReturnType error_wrapper(ReturnType return_value,
     boost::system::error_code& ec)
 {
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   ec = boost::system::error_code(WSAGetLastError(),
       boost::asio::error::get_system_category());
 #else
   ec = boost::system::error_code(errno,
       boost::asio::error::get_system_category());
 #endif
@@ -290,49 +310,49 @@ int close(socket_type s, state_type& state,
       boost::system::error_code ignored_ec;
       socket_ops::setsockopt(s, state, SOL_SOCKET,
           SO_LINGER, &opt, sizeof(opt), ignored_ec);
     }
 
     clear_last_error();
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
     result = error_wrapper(::closesocket(s), ec);
-#else // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
     result = error_wrapper(::close(s), ec);
-#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 
     if (result != 0
         && (ec == boost::asio::error::would_block
           || ec == boost::asio::error::try_again))
     {
       // According to UNIX Network Programming Vol. 1, it is possible for
       // close() to fail with EWOULDBLOCK under certain circumstances. What
       // isn't clear is the state of the descriptor after this error. The one
       // current OS where this behaviour is seen, Windows, says that the socket
       // remains open. Therefore we'll put the descriptor back into blocking
       // mode and have another attempt at closing it.
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
       ioctl_arg_type arg = 0;
       ::ioctlsocket(s, FIONBIO, &arg);
-#else // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 # if defined(__SYMBIAN32__)
       int flags = ::fcntl(s, F_GETFL, 0);
       if (flags >= 0)
         ::fcntl(s, F_SETFL, flags & ~O_NONBLOCK);
 # else // defined(__SYMBIAN32__)
       ioctl_arg_type arg = 0;
       ::ioctl(s, FIONBIO, &arg);
 # endif // defined(__SYMBIAN32__)
-#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
       state &= ~non_blocking;
 
       clear_last_error();
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
       result = error_wrapper(::closesocket(s), ec);
-#else // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
       result = error_wrapper(::close(s), ec);
-#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
     }
   }
 
   if (result == 0)
     ec = boost::system::error_code();
   return result;
@@ -345,13 +365,13 @@ bool set_user_non_blocking(socket_type s,
   {
     ec = boost::asio::error::bad_descriptor;
     return false;
   }
 
   clear_last_error();
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   ioctl_arg_type arg = (value ? 1 : 0);
   int result = error_wrapper(::ioctlsocket(s, FIONBIO, &arg), ec);
 #elif defined(__SYMBIAN32__)
   int result = error_wrapper(::fcntl(s, F_GETFL, 0), ec);
   if (result >= 0)
   {
@@ -398,13 +418,13 @@ bool set_internal_non_blocking(socket_type s,
     // caller figure out whether to update the user-set non-blocking flag.
     ec = boost::asio::error::invalid_argument;
     return false;
   }
 
   clear_last_error();
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   ioctl_arg_type arg = (value ? 1 : 0);
   int result = error_wrapper(::ioctlsocket(s, FIONBIO, &arg), ec);
 #elif defined(__SYMBIAN32__)
   int result = error_wrapper(::fcntl(s, F_GETFL, 0), ec);
   if (result >= 0)
   {
@@ -498,14 +518,63 @@ void sync_connect(socket_type s, const socket_addr_type* addr,
 
   // Return the result of the connect operation.
   ec = boost::system::error_code(connect_error,
       boost::asio::error::get_system_category());
 }
 
+#if defined(BOOST_ASIO_HAS_IOCP)
+
+void complete_iocp_connect(socket_type s, boost::system::error_code& ec)
+{
+  if (!ec)
+  {
+    // Need to set the SO_UPDATE_CONNECT_CONTEXT option so that getsockname
+    // and getpeername will work on the connected socket.
+    socket_ops::state_type state = 0;
+    const int so_update_connect_context = 0x7010;
+    socket_ops::setsockopt(s, state, SOL_SOCKET,
+        so_update_connect_context, 0, 0, ec);
+  }
+}
+
+#endif // defined(BOOST_ASIO_HAS_IOCP)
+
 bool non_blocking_connect(socket_type s, boost::system::error_code& ec)
 {
+  // Check if the connect operation has finished. This is required since we may
+  // get spurious readiness notifications from the reactor.
+#if defined(BOOST_ASIO_WINDOWS) \
+  || defined(__CYGWIN__) \
+  || defined(__SYMBIAN32__)
+  fd_set write_fds;
+  FD_ZERO(&write_fds);
+  FD_SET(s, &write_fds);
+  fd_set except_fds;
+  FD_ZERO(&except_fds);
+  FD_SET(s, &except_fds);
+  timeval zero_timeout;
+  zero_timeout.tv_sec = 0;
+  zero_timeout.tv_usec = 0;
+  int ready = ::select(s + 1, 0, &write_fds, &except_fds, &zero_timeout);
+#else // defined(BOOST_ASIO_WINDOWS)
+      // || defined(__CYGWIN__)
+      // || defined(__SYMBIAN32__)
+  pollfd fds;
+  fds.fd = s;
+  fds.events = POLLOUT;
+  fds.revents = 0;
+  int ready = ::poll(&fds, 1, 0);
+#endif // defined(BOOST_ASIO_WINDOWS)
+       // || defined(__CYGWIN__)
+       // || defined(__SYMBIAN32__)
+  if (ready == 0)
+  {
+    // The asynchronous connect operation is still in progress.
+    return false;
+  }
+
   // Get the error code from the connect operation.
   int connect_error = 0;
   size_t connect_error_len = sizeof(connect_error);
   if (socket_ops::getsockopt(s, 0, SOL_SOCKET, SO_ERROR,
         &connect_error, &connect_error_len, ec) == 0)
   {
@@ -521,13 +590,13 @@ bool non_blocking_connect(socket_type s, boost::system::error_code& ec)
   return true;
 }
 
 int socketpair(int af, int type, int protocol,
     socket_type sv[2], boost::system::error_code& ec)
 {
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   (void)(af);
   (void)(type);
   (void)(protocol);
   (void)(sv);
   ec = boost::asio::error::operation_not_supported;
   return socket_error_retval;
@@ -547,17 +616,17 @@ bool sockatmark(socket_type s, boost::system::error_code& ec)
     ec = boost::asio::error::bad_descriptor;
     return false;
   }
 
 #if defined(SIOCATMARK)
   ioctl_arg_type value = 0;
-# if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+# if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   int result = error_wrapper(::ioctlsocket(s, SIOCATMARK, &value), ec);
-# else // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+# else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   int result = error_wrapper(::ioctl(s, SIOCATMARK, &value), ec);
-# endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+# endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   if (result == 0)
     ec = boost::system::error_code();
 # if defined(ENOTTY)
   if (ec.value() == ENOTTY)
     ec = boost::asio::error::not_socket;
 # endif // defined(ENOTTY)
@@ -576,17 +645,17 @@ size_t available(socket_type s, boost::system::error_code& ec)
   {
     ec = boost::asio::error::bad_descriptor;
     return 0;
   }
 
   ioctl_arg_type value = 0;
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   int result = error_wrapper(::ioctlsocket(s, FIONREAD, &value), ec);
-#else // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   int result = error_wrapper(::ioctl(s, FIONREAD, &value), ec);
-#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   if (result == 0)
     ec = boost::system::error_code();
 #if defined(ENOTTY)
   if (ec.value() == ENOTTY)
     ec = boost::asio::error::not_socket;
 #endif // defined(ENOTTY)
@@ -617,38 +686,38 @@ inline void init_buf_iov_base(void*& base, void* addr)
 template <typename T>
 inline void init_buf_iov_base(T& base, void* addr)
 {
   base = static_cast<T>(addr);
 }
 
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 typedef WSABUF buf;
-#else // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 typedef iovec buf;
-#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 
 void init_buf(buf& b, void* data, size_t size)
 {
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   b.buf = static_cast<char*>(data);
   b.len = static_cast<u_long>(size);
-#else // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   init_buf_iov_base(b.iov_base, data);
   b.iov_len = size;
-#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 }
 
 void init_buf(buf& b, const void* data, size_t size)
 {
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   b.buf = static_cast<char*>(const_cast<void*>(data));
   b.len = static_cast<u_long>(size);
-#else // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   init_buf_iov_base(b.iov_base, const_cast<void*>(data));
   b.iov_len = size;
-#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 }
 
 inline void init_msghdr_msg_name(void*& name, socket_addr_type* addr)
 {
   name = addr;
 }
@@ -667,17 +736,17 @@ inline void init_msghdr_msg_name(T& name, socket_addr_type* addr)
 template <typename T>
 inline void init_msghdr_msg_name(T& name, const socket_addr_type* addr)
 {
   name = reinterpret_cast<T>(const_cast<socket_addr_type*>(addr));
 }
 
-int recv(socket_type s, buf* bufs, size_t count, int flags,
-    boost::system::error_code& ec)
+signed_size_type recv(socket_type s, buf* bufs, size_t count,
+    int flags, boost::system::error_code& ec)
 {
   clear_last_error();
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   // Receive some data.
   DWORD recv_buf_count = static_cast<DWORD>(count);
   DWORD bytes_transferred = 0;
   DWORD recv_flags = flags;
   int result = error_wrapper(::WSARecv(s, bufs,
         recv_buf_count, &bytes_transferred, &recv_flags, 0, 0), ec);
@@ -686,21 +755,21 @@ int recv(socket_type s, buf* bufs, size_t count, int flags,
   else if (ec.value() == ERROR_PORT_UNREACHABLE)
     ec = boost::asio::error::connection_refused;
   if (result != 0)
     return socket_error_retval;
   ec = boost::system::error_code();
   return bytes_transferred;
-#else // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   msghdr msg = msghdr();
   msg.msg_iov = bufs;
-  msg.msg_iovlen = count;
-  int result = error_wrapper(::recvmsg(s, &msg, flags), ec);
+  msg.msg_iovlen = static_cast<int>(count);
+  signed_size_type result = error_wrapper(::recvmsg(s, &msg, flags), ec);
   if (result >= 0)
     ec = boost::system::error_code();
   return result;
-#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 }
 
 size_t sync_recv(socket_type s, state_type state, buf* bufs,
     size_t count, int flags, bool all_empty, boost::system::error_code& ec)
 {
   if (s == invalid_socket)
@@ -717,13 +786,13 @@ size_t sync_recv(socket_type s, state_type state, buf* bufs,
   }
 
   // Read some data.
   for (;;)
   {
     // Try to complete the operation without blocking.
-    int bytes = socket_ops::recv(s, bufs, count, flags, ec);
+    signed_size_type bytes = socket_ops::recv(s, bufs, count, flags, ec);
 
     // Check if operation succeeded.
     if (bytes > 0)
       return bytes;
 
     // Check for EOF.
@@ -779,13 +848,13 @@ bool non_blocking_recv(socket_type s,
     buf* bufs, size_t count, int flags, bool is_stream,
     boost::system::error_code& ec, size_t& bytes_transferred)
 {
   for (;;)
   {
     // Read some data.
-    int bytes = socket_ops::recv(s, bufs, count, flags, ec);
+    signed_size_type bytes = socket_ops::recv(s, bufs, count, flags, ec);
 
     // Check for end of stream.
     if (is_stream && bytes == 0)
     {
       ec = boost::asio::error::eof;
       return true;
@@ -812,18 +881,18 @@ bool non_blocking_recv(socket_type s,
     return true;
   }
 }
 
 #endif // defined(BOOST_ASIO_HAS_IOCP)
 
-int recvfrom(socket_type s, buf* bufs, size_t count, int flags,
-    socket_addr_type* addr, std::size_t* addrlen,
+signed_size_type recvfrom(socket_type s, buf* bufs, size_t count,
+    int flags, socket_addr_type* addr, std::size_t* addrlen,
     boost::system::error_code& ec)
 {
   clear_last_error();
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   // Receive some data.
   DWORD recv_buf_count = static_cast<DWORD>(count);
   DWORD bytes_transferred = 0;
   DWORD recv_flags = flags;
   int tmp_addrlen = (int)*addrlen;
   int result = error_wrapper(::WSARecvFrom(s, bufs, recv_buf_count,
@@ -834,24 +903,24 @@ int recvfrom(socket_type s, buf* bufs, size_t count, int flags,
   else if (ec.value() == ERROR_PORT_UNREACHABLE)
     ec = boost::asio::error::connection_refused;
   if (result != 0)
     return socket_error_retval;
   ec = boost::system::error_code();
   return bytes_transferred;
-#else // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   msghdr msg = msghdr();
   init_msghdr_msg_name(msg.msg_name, addr);
-  msg.msg_namelen = *addrlen;
+  msg.msg_namelen = static_cast<int>(*addrlen);
   msg.msg_iov = bufs;
-  msg.msg_iovlen = count;
-  int result = error_wrapper(::recvmsg(s, &msg, flags), ec);
+  msg.msg_iovlen = static_cast<int>(count);
+  signed_size_type result = error_wrapper(::recvmsg(s, &msg, flags), ec);
   *addrlen = msg.msg_namelen;
   if (result >= 0)
     ec = boost::system::error_code();
   return result;
-#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 }
 
 size_t sync_recvfrom(socket_type s, state_type state, buf* bufs,
     size_t count, int flags, socket_addr_type* addr,
     std::size_t* addrlen, boost::system::error_code& ec)
 {
@@ -862,13 +931,14 @@ size_t sync_recvfrom(socket_type s, state_type state, buf* bufs,
   }
 
   // Read some data.
   for (;;)
   {
     // Try to complete the operation without blocking.
-    int bytes = socket_ops::recvfrom(s, bufs, count, flags, addr, addrlen, ec);
+    signed_size_type bytes = socket_ops::recvfrom(
+        s, bufs, count, flags, addr, addrlen, ec);
 
     // Check if operation succeeded.
     if (bytes >= 0)
       return bytes;
 
     // Operation failed.
@@ -910,13 +980,14 @@ bool non_blocking_recvfrom(socket_type s,
     socket_addr_type* addr, std::size_t* addrlen,
     boost::system::error_code& ec, size_t& bytes_transferred)
 {
   for (;;)
   {
     // Read some data.
-    int bytes = socket_ops::recvfrom(s, bufs, count, flags, addr, addrlen, ec);
+    signed_size_type bytes = socket_ops::recvfrom(
+        s, bufs, count, flags, addr, addrlen, ec);
 
     // Retry operation if interrupted by signal.
     if (ec == boost::asio::error::interrupted)
       continue;
 
     // Check if we need to run the operation again.
@@ -936,33 +1007,33 @@ bool non_blocking_recvfrom(socket_type s,
     return true;
   }
 }
 
 #endif // defined(BOOST_ASIO_HAS_IOCP)
 
-int recvmsg(socket_type s, buf* bufs, size_t count,
+signed_size_type recvmsg(socket_type s, buf* bufs, size_t count,
     int in_flags, int& out_flags, boost::system::error_code& ec)
 {
   clear_last_error();
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   out_flags = 0;
   return socket_ops::recv(s, bufs, count, in_flags, ec);
-#else // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   msghdr msg = msghdr();
   msg.msg_iov = bufs;
-  msg.msg_iovlen = count;
-  int result = error_wrapper(::recvmsg(s, &msg, in_flags), ec);
+  msg.msg_iovlen = static_cast<int>(count);
+  signed_size_type result = error_wrapper(::recvmsg(s, &msg, in_flags), ec);
   if (result >= 0)
   {
     ec = boost::system::error_code();
     out_flags = msg.msg_flags;
   }
   else
     out_flags = 0;
   return result;
-#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 }
 
 size_t sync_recvmsg(socket_type s, state_type state,
     buf* bufs, size_t count, int in_flags, int& out_flags,
     boost::system::error_code& ec)
 {
@@ -973,13 +1044,14 @@ size_t sync_recvmsg(socket_type s, state_type state,
   }
 
   // Read some data.
   for (;;)
   {
     // Try to complete the operation without blocking.
-    int bytes = socket_ops::recvmsg(s, bufs, count, in_flags, out_flags, ec);
+    signed_size_type bytes = socket_ops::recvmsg(
+        s, bufs, count, in_flags, out_flags, ec);
 
     // Check if operation succeeded.
     if (bytes >= 0)
       return bytes;
 
     // Operation failed.
@@ -1020,13 +1092,14 @@ bool non_blocking_recvmsg(socket_type s,
     buf* bufs, size_t count, int in_flags, int& out_flags,
     boost::system::error_code& ec, size_t& bytes_transferred)
 {
   for (;;)
   {
     // Read some data.
-    int bytes = socket_ops::recvmsg(s, bufs, count, in_flags, out_flags, ec);
+    signed_size_type bytes = socket_ops::recvmsg(
+        s, bufs, count, in_flags, out_flags, ec);
 
     // Retry operation if interrupted by signal.
     if (ec == boost::asio::error::interrupted)
       continue;
 
     // Check if we need to run the operation again.
@@ -1046,17 +1119,17 @@ bool non_blocking_recvmsg(socket_type s,
     return true;
   }
 }
 
 #endif // defined(BOOST_ASIO_HAS_IOCP)
 
-int send(socket_type s, const buf* bufs, size_t count, int flags,
-    boost::system::error_code& ec)
+signed_size_type send(socket_type s, const buf* bufs, size_t count,
+    int flags, boost::system::error_code& ec)
 {
   clear_last_error();
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   // Send the data.
   DWORD send_buf_count = static_cast<DWORD>(count);
   DWORD bytes_transferred = 0;
   DWORD send_flags = flags;
   int result = error_wrapper(::WSASend(s, const_cast<buf*>(bufs),
         send_buf_count, &bytes_transferred, send_flags, 0, 0), ec);
@@ -1065,24 +1138,24 @@ int send(socket_type s, const buf* bufs, size_t count, int flags,
   else if (ec.value() == ERROR_PORT_UNREACHABLE)
     ec = boost::asio::error::connection_refused;
   if (result != 0)
     return socket_error_retval;
   ec = boost::system::error_code();
   return bytes_transferred;
-#else // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   msghdr msg = msghdr();
   msg.msg_iov = const_cast<buf*>(bufs);
-  msg.msg_iovlen = count;
+  msg.msg_iovlen = static_cast<int>(count);
 #if defined(__linux__)
   flags |= MSG_NOSIGNAL;
 #endif // defined(__linux__)
-  int result = error_wrapper(::sendmsg(s, &msg, flags), ec);
+  signed_size_type result = error_wrapper(::sendmsg(s, &msg, flags), ec);
   if (result >= 0)
     ec = boost::system::error_code();
   return result;
-#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 }
 
 size_t sync_send(socket_type s, state_type state, const buf* bufs,
     size_t count, int flags, bool all_empty, boost::system::error_code& ec)
 {
   if (s == invalid_socket)
@@ -1099,13 +1172,13 @@ size_t sync_send(socket_type s, state_type state, const buf* bufs,
   }
 
   // Read some data.
   for (;;)
   {
     // Try to complete the operation without blocking.
-    int bytes = socket_ops::send(s, bufs, count, flags, ec);
+    signed_size_type bytes = socket_ops::send(s, bufs, count, flags, ec);
 
     // Check if operation succeeded.
     if (bytes >= 0)
       return bytes;
 
     // Operation failed.
@@ -1146,13 +1219,13 @@ bool non_blocking_send(socket_type s,
     const buf* bufs, size_t count, int flags,
     boost::system::error_code& ec, size_t& bytes_transferred)
 {
   for (;;)
   {
     // Write some data.
-    int bytes = socket_ops::send(s, bufs, count, flags, ec);
+    signed_size_type bytes = socket_ops::send(s, bufs, count, flags, ec);
 
     // Retry operation if interrupted by signal.
     if (ec == boost::asio::error::interrupted)
       continue;
 
     // Check if we need to run the operation again.
@@ -1172,18 +1245,18 @@ bool non_blocking_send(socket_type s,
     return true;
   }
 }
 
 #endif // defined(BOOST_ASIO_HAS_IOCP)
 
-int sendto(socket_type s, const buf* bufs, size_t count, int flags,
-    const socket_addr_type* addr, std::size_t addrlen,
+signed_size_type sendto(socket_type s, const buf* bufs, size_t count,
+    int flags, const socket_addr_type* addr, std::size_t addrlen,
     boost::system::error_code& ec)
 {
   clear_last_error();
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   // Send the data.
   DWORD send_buf_count = static_cast<DWORD>(count);
   DWORD bytes_transferred = 0;
   int result = error_wrapper(::WSASendTo(s, const_cast<buf*>(bufs),
         send_buf_count, &bytes_transferred, flags, addr,
         static_cast<int>(addrlen), 0, 0), ec);
@@ -1192,26 +1265,26 @@ int sendto(socket_type s, const buf* bufs, size_t count, int flags,
   else if (ec.value() == ERROR_PORT_UNREACHABLE)
     ec = boost::asio::error::connection_refused;
   if (result != 0)
     return socket_error_retval;
   ec = boost::system::error_code();
   return bytes_transferred;
-#else // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   msghdr msg = msghdr();
   init_msghdr_msg_name(msg.msg_name, addr);
-  msg.msg_namelen = addrlen;
+  msg.msg_namelen = static_cast<int>(addrlen);
   msg.msg_iov = const_cast<buf*>(bufs);
-  msg.msg_iovlen = count;
+  msg.msg_iovlen = static_cast<int>(count);
 #if defined(__linux__)
   flags |= MSG_NOSIGNAL;
 #endif // defined(__linux__)
-  int result = error_wrapper(::sendmsg(s, &msg, flags), ec);
+  signed_size_type result = error_wrapper(::sendmsg(s, &msg, flags), ec);
   if (result >= 0)
     ec = boost::system::error_code();
   return result;
-#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 }
 
 size_t sync_sendto(socket_type s, state_type state, const buf* bufs,
     size_t count, int flags, const socket_addr_type* addr,
     std::size_t addrlen, boost::system::error_code& ec)
 {
@@ -1222,13 +1295,14 @@ size_t sync_sendto(socket_type s, state_type state, const buf* bufs,
   }
 
   // Write some data.
   for (;;)
   {
     // Try to complete the operation without blocking.
-    int bytes = socket_ops::sendto(s, bufs, count, flags, addr, addrlen, ec);
+    signed_size_type bytes = socket_ops::sendto(
+        s, bufs, count, flags, addr, addrlen, ec);
 
     // Check if operation succeeded.
     if (bytes >= 0)
       return bytes;
 
     // Operation failed.
@@ -1250,13 +1324,14 @@ bool non_blocking_sendto(socket_type s,
     const socket_addr_type* addr, std::size_t addrlen,
     boost::system::error_code& ec, size_t& bytes_transferred)
 {
   for (;;)
   {
     // Write some data.
-    int bytes = socket_ops::sendto(s, bufs, count, flags, addr, addrlen, ec);
+    signed_size_type bytes = socket_ops::sendto(
+        s, bufs, count, flags, addr, addrlen, ec);
 
     // Retry operation if interrupted by signal.
     if (ec == boost::asio::error::interrupted)
       continue;
 
     // Check if we need to run the operation again.
@@ -1280,19 +1355,19 @@ bool non_blocking_sendto(socket_type s,
 #endif // !defined(BOOST_ASIO_HAS_IOCP)
 
 socket_type socket(int af, int type, int protocol,
     boost::system::error_code& ec)
 {
   clear_last_error();
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   socket_type s = error_wrapper(::WSASocket(af, type, protocol, 0, 0,
         WSA_FLAG_OVERLAPPED), ec);
   if (s == invalid_socket)
     return s;
 
-  if (af == AF_INET6)
+  if (af == BOOST_ASIO_OS_DEF(AF_INET6))
   {
     // Try to enable the POSIX default behaviour of having IPV6_V6ONLY set to
     // false. This will only succeed on Windows Vista and later versions of
     // Windows, where a dual-stack IPv4/v6 implementation is available.
     DWORD optval = 0;
     ::setsockopt(s, IPPROTO_IPV6, IPV6_V6ONLY,
@@ -1478,13 +1553,13 @@ int getsockopt(socket_type s, state_type state, int level, int optname,
       }
       return result;
     }
   }
   ec = boost::asio::error::fault;
   return socket_error_retval;
-#elif defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#elif defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   clear_last_error();
   int result = error_wrapper(call_getsockopt(&msghdr::msg_namelen,
         s, level, optname, optval, optlen), ec);
   if (result != 0 && level == IPPROTO_IPV6 && optname == IPV6_V6ONLY
       && ec.value() == WSAENOPROTOOPT && *optlen == sizeof(DWORD))
   {
@@ -1496,13 +1571,13 @@ int getsockopt(socket_type s, state_type state, int level, int optname,
     *static_cast<DWORD*>(optval) = 1;
     ec = boost::system::error_code();
   }
   if (result == 0)
     ec = boost::system::error_code();
   return result;
-#else // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   clear_last_error();
   int result = error_wrapper(call_getsockopt(&msghdr::msg_namelen,
         s, level, optname, optval, optlen), ec);
 #if defined(__linux__)
   if (result == 0 && level == SOL_SOCKET && *optlen == sizeof(int)
       && (optname == SO_SNDBUF || optname == SO_RCVBUF))
@@ -1515,13 +1590,13 @@ int getsockopt(socket_type s, state_type state, int level, int optname,
     *static_cast<int*>(optval) /= 2;
   }
 #endif // defined(__linux__)
   if (result == 0)
     ec = boost::system::error_code();
   return result;
-#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 }
 
 template <typename SockLenType>
 inline int call_getpeername(SockLenType msghdr::*,
     socket_type s, socket_addr_type* addr, std::size_t* addrlen)
 {
@@ -1537,13 +1612,13 @@ int getpeername(socket_type s, socket_addr_type* addr,
   if (s == invalid_socket)
   {
     ec = boost::asio::error::bad_descriptor;
     return socket_error_retval;
   }
 
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   if (cached)
   {
     // Check if socket is still connected.
     DWORD connect_time = 0;
     size_t connect_time_len = sizeof(connect_time);
     if (socket_ops::getsockopt(s, 0, SOL_SOCKET, SO_CONNECT_TIME,
@@ -1558,15 +1633,15 @@ int getpeername(socket_type s, socket_addr_type* addr,
     }
 
     // The cached value is still valid.
     ec = boost::system::error_code();
     return 0;
   }
-#else // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   (void)cached;
-#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 
   clear_last_error();
   int result = error_wrapper(call_getpeername(
         &msghdr::msg_namelen, s, addr, addrlen), ec);
   if (result == 0)
     ec = boost::system::error_code();
@@ -1607,13 +1682,13 @@ int ioctl(socket_type s, state_type& state, int cmd,
   {
     ec = boost::asio::error::bad_descriptor;
     return socket_error_retval;
   }
 
   clear_last_error();
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   int result = error_wrapper(::ioctlsocket(s, cmd, arg), ec);
 #elif defined(__MACH__) && defined(__APPLE__) \
   || defined(__NetBSD__) || defined(__FreeBSD__) || defined(__OpenBSD__)
   int result = error_wrapper(::ioctl(s,
         static_cast<unsigned int>(cmd), arg), ec);
 #else
@@ -1648,13 +1723,13 @@ int ioctl(socket_type s, state_type& state, int cmd,
 }
 
 int select(int nfds, fd_set* readfds, fd_set* writefds,
     fd_set* exceptfds, timeval* timeout, boost::system::error_code& ec)
 {
   clear_last_error();
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   if (!readfds && !writefds && !exceptfds && timeout)
   {
     DWORD milliseconds = timeout->tv_sec * 1000 + timeout->tv_usec / 1000;
     if (milliseconds == 0)
       milliseconds = 1; // Force context switch.
     ::Sleep(milliseconds);
@@ -1668,13 +1743,13 @@ int select(int nfds, fd_set* readfds, fd_set* writefds,
   // reactor, meaning increased CPU usage, when waiting for the earliest
   // scheduled timeout if it's less than 10 milliseconds away. To avoid a tight
   // spin we'll use a minimum timeout of 1 millisecond.
   if (timeout && timeout->tv_sec == 0
       && timeout->tv_usec > 0 && timeout->tv_usec < 1000)
     timeout->tv_usec = 1000;
-#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 
 #if defined(__hpux) && defined(__SELECT)
   timespec ts;
   ts.tv_sec = timeout ? timeout->tv_sec : 0;
   ts.tv_nsec = timeout ? timeout->tv_usec * 1000 : 0;
   return error_wrapper(::pselect(nfds, readfds,
@@ -1693,35 +1768,35 @@ int poll_read(socket_type s, state_type state, boost::system::error_code& ec)
   if (s == invalid_socket)
   {
     ec = boost::asio::error::bad_descriptor;
     return socket_error_retval;
   }
 
-#if defined(BOOST_WINDOWS) \
+#if defined(BOOST_ASIO_WINDOWS) \
   || defined(__CYGWIN__) \
   || defined(__SYMBIAN32__)
   fd_set fds;
   FD_ZERO(&fds);
   FD_SET(s, &fds);
   timeval zero_timeout;
   zero_timeout.tv_sec = 0;
   zero_timeout.tv_usec = 0;
   timeval* timeout = (state & user_set_non_blocking) ? &zero_timeout : 0;
   clear_last_error();
-  int result = error_wrapper(::select(s, &fds, 0, 0, timeout), ec);
-#else // defined(BOOST_WINDOWS)
+  int result = error_wrapper(::select(s + 1, &fds, 0, 0, timeout), ec);
+#else // defined(BOOST_ASIO_WINDOWS)
       // || defined(__CYGWIN__)
       // || defined(__SYMBIAN32__)
   pollfd fds;
   fds.fd = s;
   fds.events = POLLIN;
   fds.revents = 0;
   int timeout = (state & user_set_non_blocking) ? 0 : -1;
   clear_last_error();
   int result = error_wrapper(::poll(&fds, 1, timeout), ec);
-#endif // defined(BOOST_WINDOWS)
+#endif // defined(BOOST_ASIO_WINDOWS)
        // || defined(__CYGWIN__)
        // || defined(__SYMBIAN32__)
   if (result == 0)
     ec = (state & user_set_non_blocking)
       ? boost::asio::error::would_block : boost::system::error_code();
   else if (result > 0)
@@ -1734,35 +1809,35 @@ int poll_write(socket_type s, state_type state, boost::system::error_code& ec)
   if (s == invalid_socket)
   {
     ec = boost::asio::error::bad_descriptor;
     return socket_error_retval;
   }
 
-#if defined(BOOST_WINDOWS) \
+#if defined(BOOST_ASIO_WINDOWS) \
   || defined(__CYGWIN__) \
   || defined(__SYMBIAN32__)
   fd_set fds;
   FD_ZERO(&fds);
   FD_SET(s, &fds);
   timeval zero_timeout;
   zero_timeout.tv_sec = 0;
   zero_timeout.tv_usec = 0;
   timeval* timeout = (state & user_set_non_blocking) ? &zero_timeout : 0;
   clear_last_error();
-  int result = error_wrapper(::select(s, 0, &fds, 0, timeout), ec);
-#else // defined(BOOST_WINDOWS)
+  int result = error_wrapper(::select(s + 1, 0, &fds, 0, timeout), ec);
+#else // defined(BOOST_ASIO_WINDOWS)
       // || defined(__CYGWIN__)
       // || defined(__SYMBIAN32__)
   pollfd fds;
   fds.fd = s;
   fds.events = POLLOUT;
   fds.revents = 0;
   int timeout = (state & user_set_non_blocking) ? 0 : -1;
   clear_last_error();
   int result = error_wrapper(::poll(&fds, 1, timeout), ec);
-#endif // defined(BOOST_WINDOWS)
+#endif // defined(BOOST_ASIO_WINDOWS)
        // || defined(__CYGWIN__)
        // || defined(__SYMBIAN32__)
   if (result == 0)
     ec = (state & user_set_non_blocking)
       ? boost::asio::error::would_block : boost::system::error_code();
   else if (result > 0)
@@ -1775,51 +1850,89 @@ int poll_connect(socket_type s, boost::system::error_code& ec)
   if (s == invalid_socket)
   {
     ec = boost::asio::error::bad_descriptor;
     return socket_error_retval;
   }
 
-#if defined(BOOST_WINDOWS) \
+#if defined(BOOST_ASIO_WINDOWS) \
   || defined(__CYGWIN__) \
   || defined(__SYMBIAN32__)
   fd_set write_fds;
   FD_ZERO(&write_fds);
   FD_SET(s, &write_fds);
   fd_set except_fds;
   FD_ZERO(&except_fds);
   FD_SET(s, &except_fds);
   clear_last_error();
-  int result = error_wrapper(::select(s, 0, &write_fds, &except_fds, 0), ec);
+  int result = error_wrapper(::select(
+        s + 1, 0, &write_fds, &except_fds, 0), ec);
   if (result >= 0)
     ec = boost::system::error_code();
   return result;
-#else // defined(BOOST_WINDOWS)
+#else // defined(BOOST_ASIO_WINDOWS)
       // || defined(__CYGWIN__)
       // || defined(__SYMBIAN32__)
   pollfd fds;
   fds.fd = s;
   fds.events = POLLOUT;
   fds.revents = 0;
   clear_last_error();
   int result = error_wrapper(::poll(&fds, 1, -1), ec);
   if (result >= 0)
     ec = boost::system::error_code();
   return result;
-#endif // defined(BOOST_WINDOWS)
+#endif // defined(BOOST_ASIO_WINDOWS)
        // || defined(__CYGWIN__)
        // || defined(__SYMBIAN32__)
 }
 
+#endif // !defined(BOOST_ASIO_WINDOWS_RUNTIME)
+
 const char* inet_ntop(int af, const void* src, char* dest, size_t length,
     unsigned long scope_id, boost::system::error_code& ec)
 {
   clear_last_error();
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#if defined(BOOST_ASIO_WINDOWS_RUNTIME)
+  using namespace std; // For sprintf.
+  const unsigned char* bytes = static_cast<const unsigned char*>(src);
+  if (af == BOOST_ASIO_OS_DEF(AF_INET))
+  {
+    sprintf_s(dest, length, "%u.%u.%u.%u",
+        bytes[0], bytes[1], bytes[2], bytes[3]);
+    return dest;
+  }
+  else if (af == BOOST_ASIO_OS_DEF(AF_INET6))
+  {
+    size_t n = 0, b = 0, z = 0;
+    while (n < length && b < 16)
+    {
+      if (bytes[b] == 0 && bytes[b + 1] == 0 && z == 0)
+      {
+        do b += 2; while (b < 16 && bytes[b] == 0 && bytes[b + 1] == 0);
+        n += sprintf_s(dest + n, length - n, ":%s", b < 16 ? "" : ":"), ++z;
+      }
+      else
+      {
+        n += sprintf_s(dest + n, length - n, "%s%x", b ? ":" : "",
+            (static_cast<u_long_type>(bytes[b]) << 8) | bytes[b + 1]);
+        b += 2;
+      }
+    }
+    if (scope_id)
+      n += sprintf_s(dest + n, length - n, "%%%lu", scope_id);
+    return dest;
+  }
+  else
+  {
+    ec = boost::asio::error::address_family_not_supported;
+    return 0;
+  }
+#elif defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   using namespace std; // For memcpy.
 
-  if (af != AF_INET && af != AF_INET6)
+  if (af != BOOST_ASIO_OS_DEF(AF_INET) && af != BOOST_ASIO_OS_DEF(AF_INET6))
   {
     ec = boost::asio::error::address_family_not_supported;
     return 0;
   }
 
   union
@@ -1827,31 +1940,31 @@ const char* inet_ntop(int af, const void* src, char* dest, size_t length,
     socket_addr_type base;
     sockaddr_storage_type storage;
     sockaddr_in4_type v4;
     sockaddr_in6_type v6;
   } address;
   DWORD address_length;
-  if (af == AF_INET)
+  if (af == BOOST_ASIO_OS_DEF(AF_INET))
   {
     address_length = sizeof(sockaddr_in4_type);
-    address.v4.sin_family = AF_INET;
+    address.v4.sin_family = BOOST_ASIO_OS_DEF(AF_INET);
     address.v4.sin_port = 0;
     memcpy(&address.v4.sin_addr, src, sizeof(in4_addr_type));
   }
   else // AF_INET6
   {
     address_length = sizeof(sockaddr_in6_type);
-    address.v6.sin6_family = AF_INET6;
+    address.v6.sin6_family = BOOST_ASIO_OS_DEF(AF_INET6);
     address.v6.sin6_port = 0;
     address.v6.sin6_flowinfo = 0;
     address.v6.sin6_scope_id = scope_id;
     memcpy(&address.v6.sin6_addr, src, sizeof(in6_addr_type));
   }
 
   DWORD string_length = static_cast<DWORD>(length);
-#if defined(BOOST_NO_ANSI_APIS)
+#if defined(BOOST_NO_ANSI_APIS) || (defined(_MSC_VER) && (_MSC_VER >= 1800))
   LPWSTR string_buffer = (LPWSTR)_alloca(length * sizeof(WCHAR));
   int result = error_wrapper(::WSAAddressToStringW(&address.base,
         address_length, 0, string_buffer, &string_length), ec);
   ::WideCharToMultiByte(CP_ACP, 0, string_buffer, -1, dest, length, 0, 0);
 #else
   int result = error_wrapper(::WSAAddressToStringA(
@@ -1864,39 +1977,187 @@ const char* inet_ntop(int af, const void* src, char* dest, size_t length,
 
   // Windows may not set an error code on failure.
   else if (result == socket_error_retval && !ec)
     ec = boost::asio::error::invalid_argument;
 
   return result == socket_error_retval ? 0 : dest;
-#else // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
-  const char* result = error_wrapper(::inet_ntop(af, src, dest, length), ec);
+#else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
+  const char* result = error_wrapper(::inet_ntop(
+        af, src, dest, static_cast<int>(length)), ec);
   if (result == 0 && !ec)
     ec = boost::asio::error::invalid_argument;
-  if (result != 0 && af == AF_INET6 && scope_id != 0)
+  if (result != 0 && af == BOOST_ASIO_OS_DEF(AF_INET6) && scope_id != 0)
   {
     using namespace std; // For strcat and sprintf.
     char if_name[IF_NAMESIZE + 1] = "%";
     const in6_addr_type* ipv6_address = static_cast<const in6_addr_type*>(src);
     bool is_link_local = ((ipv6_address->s6_addr[0] == 0xfe)
         && ((ipv6_address->s6_addr[1] & 0xc0) == 0x80));
-    if (!is_link_local || if_indextoname(scope_id, if_name + 1) == 0)
+    bool is_multicast_link_local = ((ipv6_address->s6_addr[0] == 0xff)
+        && ((ipv6_address->s6_addr[1] & 0x0f) == 0x02));
+    if ((!is_link_local && !is_multicast_link_local)
+        || if_indextoname(static_cast<unsigned>(scope_id), if_name + 1) == 0)
       sprintf(if_name + 1, "%lu", scope_id);
     strcat(dest, if_name);
   }
   return result;
-#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 }
 
 int inet_pton(int af, const char* src, void* dest,
     unsigned long* scope_id, boost::system::error_code& ec)
 {
   clear_last_error();
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#if defined(BOOST_ASIO_WINDOWS_RUNTIME)
+  using namespace std; // For sscanf.
+  unsigned char* bytes = static_cast<unsigned char*>(dest);
+  if (af == BOOST_ASIO_OS_DEF(AF_INET))
+  {
+    unsigned int b0, b1, b2, b3;
+    if (sscanf_s(src, "%u.%u.%u.%u", &b0, &b1, &b2, &b3) != 4)
+    {
+      ec = boost::asio::error::invalid_argument;
+      return -1;
+    }
+    if (b0 > 255 || b1 > 255 || b2 > 255 || b3 > 255)
+    {
+      ec = boost::asio::error::invalid_argument;
+      return -1;
+    }
+    bytes[0] = static_cast<unsigned char>(b0);
+    bytes[1] = static_cast<unsigned char>(b1);
+    bytes[2] = static_cast<unsigned char>(b2);
+    bytes[3] = static_cast<unsigned char>(b3);
+    ec = boost::system::error_code();
+    return 1;
+  }
+  else if (af == BOOST_ASIO_OS_DEF(AF_INET6))
+  {
+    unsigned char* bytes = static_cast<unsigned char*>(dest);
+    std::memset(bytes, 0, 16);
+    unsigned char back_bytes[16] = { 0 };
+    int num_front_bytes = 0, num_back_bytes = 0;
+    const char* p = src;
+
+    enum { fword, fcolon, bword, scope, done } state = fword;
+    unsigned long current_word = 0;
+    while (state != done)
+    {
+      if (current_word > 0xFFFF)
+      {
+        ec = boost::asio::error::invalid_argument;
+        return -1;
+      }
+
+      switch (state)
+      {
+      case fword:
+        if (*p >= '0' && *p <= '9')
+          current_word = current_word * 16 + *p++ - '0';
+        else if (*p >= 'a' && *p <= 'f')
+          current_word = current_word * 16 + *p++ - 'a' + 10;
+        else if (*p >= 'A' && *p <= 'F')
+          current_word = current_word * 16 + *p++ - 'A' + 10;
+        else
+        {
+          if (num_front_bytes == 16)
+          {
+            ec = boost::asio::error::invalid_argument;
+            return -1;
+          }
+
+          bytes[num_front_bytes++] = (current_word >> 8) & 0xFF;
+          bytes[num_front_bytes++] = current_word & 0xFF;
+          current_word = 0;
+
+          if (*p == ':')
+            state = fcolon, ++p;
+          else if (*p == '%')
+            state = scope, ++p;
+          else if (*p == 0)
+            state = done;
+          else
+          {
+            ec = boost::asio::error::invalid_argument;
+            return -1;
+          }
+        }
+        break;
+
+      case fcolon:
+        if (*p == ':')
+          state = bword, ++p;
+        else
+          state = fword;
+        break;
+
+      case bword:
+        if (*p >= '0' && *p <= '9')
+          current_word = current_word * 16 + *p++ - '0';
+        else if (*p >= 'a' && *p <= 'f')
+          current_word = current_word * 16 + *p++ - 'a' + 10;
+        else if (*p >= 'A' && *p <= 'F')
+          current_word = current_word * 16 + *p++ - 'A' + 10;
+        else
+        {
+          if (num_front_bytes + num_back_bytes == 16)
+          {
+            ec = boost::asio::error::invalid_argument;
+            return -1;
+          }
+
+          back_bytes[num_back_bytes++] = (current_word >> 8) & 0xFF;
+          back_bytes[num_back_bytes++] = current_word & 0xFF;
+          current_word = 0;
+
+          if (*p == ':')
+            state = bword, ++p;
+          else if (*p == '%')
+            state = scope, ++p;
+          else if (*p == 0)
+            state = done;
+          else
+          {
+            ec = boost::asio::error::invalid_argument;
+            return -1;
+          }
+        }
+        break;
+
+      case scope:
+        if (*p >= '0' && *p <= '9')
+          current_word = current_word * 10 + *p++ - '0';
+        else if (*p == 0)
+          *scope_id = current_word, state = done;
+        else
+        {
+          ec = boost::asio::error::invalid_argument;
+          return -1;
+        }
+        break;
+
+      default:
+        break;
+      }
+    }
+
+    for (int i = 0; i < num_back_bytes; ++i)
+      bytes[16 - num_back_bytes + i] = back_bytes[i];
+
+    ec = boost::system::error_code();
+    return 1;
+  }
+  else
+  {
+    ec = boost::asio::error::address_family_not_supported;
+    return -1;
+  }
+#elif defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   using namespace std; // For memcpy and strcmp.
 
-  if (af != AF_INET && af != AF_INET6)
+  if (af != BOOST_ASIO_OS_DEF(AF_INET) && af != BOOST_ASIO_OS_DEF(AF_INET6))
   {
     ec = boost::asio::error::address_family_not_supported;
     return -1;
   }
 
   union
@@ -1904,24 +2165,24 @@ int inet_pton(int af, const char* src, void* dest,
     socket_addr_type base;
     sockaddr_storage_type storage;
     sockaddr_in4_type v4;
     sockaddr_in6_type v6;
   } address;
   int address_length = sizeof(sockaddr_storage_type);
-#if defined(BOOST_NO_ANSI_APIS)
+#if defined(BOOST_NO_ANSI_APIS) || (defined(_MSC_VER) && (_MSC_VER >= 1800))
   int num_wide_chars = strlen(src) + 1;
   LPWSTR wide_buffer = (LPWSTR)_alloca(num_wide_chars * sizeof(WCHAR));
   ::MultiByteToWideChar(CP_ACP, 0, src, -1, wide_buffer, num_wide_chars);
   int result = error_wrapper(::WSAStringToAddressW(
         wide_buffer, af, 0, &address.base, &address_length), ec);
 #else
   int result = error_wrapper(::WSAStringToAddressA(
         const_cast<char*>(src), af, 0, &address.base, &address_length), ec);
 #endif
 
-  if (af == AF_INET)
+  if (af == BOOST_ASIO_OS_DEF(AF_INET))
   {
     if (result != socket_error_retval)
     {
       memcpy(dest, &address.v4.sin_addr, sizeof(in4_addr_type));
       ec = boost::system::error_code();
     }
@@ -1947,48 +2208,82 @@ int inet_pton(int af, const char* src, void* dest,
     ec = boost::asio::error::invalid_argument;
 
   if (result != socket_error_retval)
     ec = boost::system::error_code();
 
   return result == socket_error_retval ? -1 : 1;
-#else // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   int result = error_wrapper(::inet_pton(af, src, dest), ec);
   if (result <= 0 && !ec)
     ec = boost::asio::error::invalid_argument;
-  if (result > 0 && af == AF_INET6 && scope_id)
+  if (result > 0 && af == BOOST_ASIO_OS_DEF(AF_INET6) && scope_id)
   {
     using namespace std; // For strchr and atoi.
     *scope_id = 0;
     if (const char* if_name = strchr(src, '%'))
     {
       in6_addr_type* ipv6_address = static_cast<in6_addr_type*>(dest);
       bool is_link_local = ((ipv6_address->s6_addr[0] == 0xfe)
           && ((ipv6_address->s6_addr[1] & 0xc0) == 0x80));
-      if (is_link_local)
+      bool is_multicast_link_local = ((ipv6_address->s6_addr[0] == 0xff)
+          && ((ipv6_address->s6_addr[1] & 0x0f) == 0x02));
+      if (is_link_local || is_multicast_link_local)
         *scope_id = if_nametoindex(if_name + 1);
       if (*scope_id == 0)
         *scope_id = atoi(if_name + 1);
     }
   }
   return result;
-#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 }
 
 int gethostname(char* name, int namelen, boost::system::error_code& ec)
 {
   clear_last_error();
+#if defined(BOOST_ASIO_WINDOWS_RUNTIME)
+  try
+  {
+    using namespace Windows::Foundation::Collections;
+    using namespace Windows::Networking;
+    using namespace Windows::Networking::Connectivity;
+    IVectorView<HostName^>^ hostnames = NetworkInformation::GetHostNames();
+    for (unsigned i = 0; i < hostnames->Size; ++i)
+    {
+      HostName^ hostname = hostnames->GetAt(i);
+      if (hostname->Type == HostNameType::DomainName)
+      {
+        std::wstring_convert<std::codecvt_utf8<wchar_t>> converter;
+        std::string raw_name = converter.to_bytes(hostname->RawName->Data());
+        if (namelen > 0 && raw_name.size() < static_cast<std::size_t>(namelen))
+        {
+          strcpy_s(name, namelen, raw_name.c_str());
+          return 0;
+        }
+      }
+    }
+    return -1;
+  }
+  catch (Platform::Exception^ e)
+  {
+    ec = boost::system::error_code(e->HResult,
+        boost::system::system_category());
+    return -1;
+  }
+#else // defined(BOOST_ASIO_WINDOWS_RUNTIME)
   int result = error_wrapper(::gethostname(name, namelen), ec);
-#if defined(BOOST_WINDOWS)
+# if defined(BOOST_ASIO_WINDOWS)
   if (result == 0)
     ec = boost::system::error_code();
-#endif
+# endif // defined(BOOST_ASIO_WINDOWS)
   return result;
+#endif // defined(BOOST_ASIO_WINDOWS_RUNTIME)
 }
 
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__) \
-  || defined(__MACH__) && defined(__APPLE__)
+#if !defined(BOOST_ASIO_WINDOWS_RUNTIME)
+
+#if !defined(BOOST_ASIO_HAS_GETADDRINFO)
 
 // The following functions are only needed for emulation of getaddrinfo and
 // getnameinfo.
 
 inline boost::system::error_code translate_netdb_error(int error)
 {
@@ -2002,22 +2297,22 @@ inline boost::system::error_code translate_netdb_error(int error)
     return boost::asio::error::host_not_found_try_again;
   case NO_RECOVERY:
     return boost::asio::error::no_recovery;
   case NO_DATA:
     return boost::asio::error::no_data;
   default:
-    BOOST_ASSERT(false);
+    BOOST_ASIO_ASSERT(false);
     return boost::asio::error::invalid_argument;
   }
 }
 
 inline hostent* gethostbyaddr(const char* addr, int length, int af,
     hostent* result, char* buffer, int buflength, boost::system::error_code& ec)
 {
   clear_last_error();
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   (void)(buffer);
   (void)(buflength);
   hostent* retval = error_wrapper(::gethostbyaddr(addr, length, af), ec);
   if (!retval)
     return 0;
   ec = boost::system::error_code();
@@ -2054,30 +2349,30 @@ inline hostent* gethostbyaddr(const char* addr, int length, int af,
 }
 
 inline hostent* gethostbyname(const char* name, int af, struct hostent* result,
     char* buffer, int buflength, int ai_flags, boost::system::error_code& ec)
 {
   clear_last_error();
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   (void)(buffer);
   (void)(buflength);
   (void)(ai_flags);
-  if (af != AF_INET)
+  if (af != BOOST_ASIO_OS_DEF(AF_INET))
   {
     ec = boost::asio::error::address_family_not_supported;
     return 0;
   }
   hostent* retval = error_wrapper(::gethostbyname(name), ec);
   if (!retval)
     return 0;
   ec = boost::system::error_code();
   *result = *retval;
   return result;
 #elif defined(__sun) || defined(__QNX__)
   (void)(ai_flags);
-  if (af != AF_INET)
+  if (af != BOOST_ASIO_OS_DEF(AF_INET))
   {
     ec = boost::asio::error::address_family_not_supported;
     return 0;
   }
   int error = 0;
   hostent* retval = error_wrapper(::gethostbyname_r(name, result, buffer,
@@ -2096,13 +2391,13 @@ inline hostent* gethostbyname(const char* name, int af, struct hostent* result,
   if (!retval)
     return 0;
   *result = *retval;
   return retval;
 #else
   (void)(ai_flags);
-  if (af != AF_INET)
+  if (af != BOOST_ASIO_OS_DEF(AF_INET))
   {
     ec = boost::asio::error::address_family_not_supported;
     return 0;
   }
   hostent* retval = 0;
   int error = 0;
@@ -2141,83 +2436,83 @@ inline int gai_nsearch(const char* host,
   {
     if (hints->ai_flags & AI_PASSIVE)
     {
       // No host and AI_PASSIVE implies wildcard bind.
       switch (hints->ai_family)
       {
-      case AF_INET:
+      case BOOST_ASIO_OS_DEF(AF_INET):
         search[search_count].host = "0.0.0.0";
-        search[search_count].family = AF_INET;
+        search[search_count].family = BOOST_ASIO_OS_DEF(AF_INET);
         ++search_count;
         break;
-      case AF_INET6:
+      case BOOST_ASIO_OS_DEF(AF_INET6):
         search[search_count].host = "0::0";
-        search[search_count].family = AF_INET6;
+        search[search_count].family = BOOST_ASIO_OS_DEF(AF_INET6);
         ++search_count;
         break;
-      case AF_UNSPEC:
+      case BOOST_ASIO_OS_DEF(AF_UNSPEC):
         search[search_count].host = "0::0";
-        search[search_count].family = AF_INET6;
+        search[search_count].family = BOOST_ASIO_OS_DEF(AF_INET6);
         ++search_count;
         search[search_count].host = "0.0.0.0";
-        search[search_count].family = AF_INET;
+        search[search_count].family = BOOST_ASIO_OS_DEF(AF_INET);
         ++search_count;
         break;
       default:
         break;
       }
     }
     else
     {
       // No host and not AI_PASSIVE means connect to local host.
       switch (hints->ai_family)
       {
-      case AF_INET:
+      case BOOST_ASIO_OS_DEF(AF_INET):
         search[search_count].host = "localhost";
-        search[search_count].family = AF_INET;
+        search[search_count].family = BOOST_ASIO_OS_DEF(AF_INET);
         ++search_count;
         break;
-      case AF_INET6:
+      case BOOST_ASIO_OS_DEF(AF_INET6):
         search[search_count].host = "localhost";
-        search[search_count].family = AF_INET6;
+        search[search_count].family = BOOST_ASIO_OS_DEF(AF_INET6);
         ++search_count;
         break;
-      case AF_UNSPEC:
+      case BOOST_ASIO_OS_DEF(AF_UNSPEC):
         search[search_count].host = "localhost";
-        search[search_count].family = AF_INET6;
+        search[search_count].family = BOOST_ASIO_OS_DEF(AF_INET6);
         ++search_count;
         search[search_count].host = "localhost";
-        search[search_count].family = AF_INET;
+        search[search_count].family = BOOST_ASIO_OS_DEF(AF_INET);
         ++search_count;
         break;
       default:
         break;
       }
     }
   }
   else
   {
     // Host is specified.
     switch (hints->ai_family)
     {
-    case AF_INET:
+    case BOOST_ASIO_OS_DEF(AF_INET):
       search[search_count].host = host;
-      search[search_count].family = AF_INET;
+      search[search_count].family = BOOST_ASIO_OS_DEF(AF_INET);
       ++search_count;
       break;
-    case AF_INET6:
+    case BOOST_ASIO_OS_DEF(AF_INET6):
       search[search_count].host = host;
-      search[search_count].family = AF_INET6;
+      search[search_count].family = BOOST_ASIO_OS_DEF(AF_INET6);
       ++search_count;
       break;
-    case AF_UNSPEC:
+    case BOOST_ASIO_OS_DEF(AF_UNSPEC):
       search[search_count].host = host;
-      search[search_count].family = AF_INET6;
+      search[search_count].family = BOOST_ASIO_OS_DEF(AF_INET6);
       ++search_count;
       search[search_count].host = host;
-      search[search_count].family = AF_INET;
+      search[search_count].family = BOOST_ASIO_OS_DEF(AF_INET);
       ++search_count;
       break;
     default:
       break;
     }
   }
@@ -2239,18 +2534,18 @@ inline void gai_free(void* p)
   ::operator delete(p);
 }
 
 inline void gai_strcpy(char* target, const char* source, std::size_t max_size)
 {
   using namespace std;
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) && !defined(UNDER_CE)
+#if defined(BOOST_ASIO_HAS_SECURE_RTL)
   strcpy_s(target, max_size, source);
-#else
+#else // defined(BOOST_ASIO_HAS_SECURE_RTL)
   *target = 0;
   strncat(target, source, max_size);
-#endif
+#endif // defined(BOOST_ASIO_HAS_SECURE_RTL)
 }
 
 enum { gai_clone_flag = 1 << 30 };
 
 inline int gai_aistruct(addrinfo_type*** next, const addrinfo_type* hints,
     const void* addr, int family)
@@ -2271,29 +2566,29 @@ inline int gai_aistruct(addrinfo_type*** next, const addrinfo_type* hints,
     ai->ai_flags |= gai_clone_flag;
   ai->ai_protocol = hints->ai_protocol;
   ai->ai_family = family;
 
   switch (ai->ai_family)
   {
-  case AF_INET:
+  case BOOST_ASIO_OS_DEF(AF_INET):
     {
       sockaddr_in4_type* sinptr = gai_alloc<sockaddr_in4_type>();
       if (sinptr == 0)
         return EAI_MEMORY;
-      sinptr->sin_family = AF_INET;
+      sinptr->sin_family = BOOST_ASIO_OS_DEF(AF_INET);
       memcpy(&sinptr->sin_addr, addr, sizeof(in4_addr_type));
       ai->ai_addr = reinterpret_cast<sockaddr*>(sinptr);
       ai->ai_addrlen = sizeof(sockaddr_in4_type);
       break;
     }
-  case AF_INET6:
+  case BOOST_ASIO_OS_DEF(AF_INET6):
     {
       sockaddr_in6_type* sin6ptr = gai_alloc<sockaddr_in6_type>();
       if (sin6ptr == 0)
         return EAI_MEMORY;
-      sin6ptr->sin6_family = AF_INET6;
+      sin6ptr->sin6_family = BOOST_ASIO_OS_DEF(AF_INET6);
       memcpy(&sin6ptr->sin6_addr, addr, sizeof(in6_addr_type));
       ai->ai_addr = reinterpret_cast<sockaddr*>(sin6ptr);
       ai->ai_addrlen = sizeof(sockaddr_in6_type);
       break;
     }
   default:
@@ -2349,21 +2644,21 @@ inline int gai_port(addrinfo_type* aihead, int port, int socktype)
     }
 
     ai->ai_socktype = socktype;
 
     switch (ai->ai_family)
     {
-    case AF_INET:
+    case BOOST_ASIO_OS_DEF(AF_INET):
       {
         sockaddr_in4_type* sinptr =
           reinterpret_cast<sockaddr_in4_type*>(ai->ai_addr);
         sinptr->sin_port = port;
         ++num_found;
         break;
       }
-    case AF_INET6:
+    case BOOST_ASIO_OS_DEF(AF_INET6):
       {
         sockaddr_in6_type* sin6ptr =
           reinterpret_cast<sockaddr_in6_type*>(ai->ai_addr);
         sin6ptr->sin6_port = port;
         ++num_found;
         break;
@@ -2466,16 +2761,16 @@ inline int gai_echeck(const char* host, const char* service,
     if (service == 0 || service[0] == '\0')
       return EAI_NONAME;
 
   // Check combination of family and socket type.
   switch (family)
   {
-  case AF_UNSPEC:
+  case BOOST_ASIO_OS_DEF(AF_UNSPEC):
     break;
-  case AF_INET:
-  case AF_INET6:
+  case BOOST_ASIO_OS_DEF(AF_INET):
+  case BOOST_ASIO_OS_DEF(AF_INET6):
     if (service != 0 && service[0] != '\0')
       if (socktype != 0 && socktype != SOCK_STREAM && socktype != SOCK_DGRAM)
         return EAI_SOCKTYPE;
     break;
   default:
     return EAI_FAMILY;
@@ -2504,24 +2799,24 @@ inline int getaddrinfo_emulation(const char* host, const char* service,
   addrinfo_type* aihead = 0;
   addrinfo_type** ainext = &aihead;
   char* canon = 0;
 
   // Supply default hints if not specified by caller.
   addrinfo_type hints = addrinfo_type();
-  hints.ai_family = AF_UNSPEC;
+  hints.ai_family = BOOST_ASIO_OS_DEF(AF_UNSPEC);
   if (hintsp)
     hints = *hintsp;
 
   // If the resolution is not specifically for AF_INET6, remove the AI_V4MAPPED
   // and AI_ALL flags.
 #if defined(AI_V4MAPPED)
-  if (hints.ai_family != AF_INET6)
+  if (hints.ai_family != BOOST_ASIO_OS_DEF(AF_INET6))
     hints.ai_flags &= ~AI_V4MAPPED;
 #endif
 #if defined(AI_ALL)
-  if (hints.ai_family != AF_INET6)
+  if (hints.ai_family != BOOST_ASIO_OS_DEF(AF_INET6))
     hints.ai_flags &= ~AI_ALL;
 #endif
 
   // Basic error checking.
   int rc = gai_echeck(host, service, hints.ai_flags, hints.ai_family,
       hints.ai_socktype, hints.ai_protocol);
@@ -2535,46 +2830,51 @@ inline int getaddrinfo_emulation(const char* host, const char* service,
   int search_count = gai_nsearch(host, &hints, search);
   for (gai_search* sptr = search; sptr < search + search_count; ++sptr)
   {
     // Check for IPv4 dotted decimal string.
     in4_addr_type inaddr;
     boost::system::error_code ec;
-    if (socket_ops::inet_pton(AF_INET, sptr->host, &inaddr, 0, ec) == 1)
+    if (socket_ops::inet_pton(BOOST_ASIO_OS_DEF(AF_INET),
+          sptr->host, &inaddr, 0, ec) == 1)
     {
-      if (hints.ai_family != AF_UNSPEC && hints.ai_family != AF_INET)
+      if (hints.ai_family != BOOST_ASIO_OS_DEF(AF_UNSPEC)
+          && hints.ai_family != BOOST_ASIO_OS_DEF(AF_INET))
       {
         freeaddrinfo_emulation(aihead);
         gai_free(canon);
         return EAI_FAMILY;
       }
-      if (sptr->family == AF_INET)
+      if (sptr->family == BOOST_ASIO_OS_DEF(AF_INET))
       {
-        rc = gai_aistruct(&ainext, &hints, &inaddr, AF_INET);
+        rc = gai_aistruct(&ainext, &hints, &inaddr, BOOST_ASIO_OS_DEF(AF_INET));
         if (rc != 0)
         {
           freeaddrinfo_emulation(aihead);
           gai_free(canon);
           return rc;
         }
       }
       continue;
     }
 
     // Check for IPv6 hex string.
     in6_addr_type in6addr;
-    if (socket_ops::inet_pton(AF_INET6, sptr->host, &in6addr, 0, ec) == 1)
+    if (socket_ops::inet_pton(BOOST_ASIO_OS_DEF(AF_INET6),
+          sptr->host, &in6addr, 0, ec) == 1)
     {
-      if (hints.ai_family != AF_UNSPEC && hints.ai_family != AF_INET6)
+      if (hints.ai_family != BOOST_ASIO_OS_DEF(AF_UNSPEC)
+          && hints.ai_family != BOOST_ASIO_OS_DEF(AF_INET6))
       {
         freeaddrinfo_emulation(aihead);
         gai_free(canon);
         return EAI_FAMILY;
       }
-      if (sptr->family == AF_INET6)
+      if (sptr->family == BOOST_ASIO_OS_DEF(AF_INET6))
       {
-        rc = gai_aistruct(&ainext, &hints, &in6addr, AF_INET6);
+        rc = gai_aistruct(&ainext, &hints, &in6addr,
+            BOOST_ASIO_OS_DEF(AF_INET6));
         if (rc != 0)
         {
           freeaddrinfo_emulation(aihead);
           gai_free(canon);
           return rc;
         }
@@ -2605,13 +2905,14 @@ inline int getaddrinfo_emulation(const char* host, const char* service,
       if (ec == boost::asio::error::no_data)
         return EAI_NONAME;
       return EAI_NONAME;
     }
 
     // Check for address family mismatch if one was specified.
-    if (hints.ai_family != AF_UNSPEC && hints.ai_family != hptr->h_addrtype)
+    if (hints.ai_family != BOOST_ASIO_OS_DEF(AF_UNSPEC)
+        && hints.ai_family != hptr->h_addrtype)
     {
       freeaddrinfo_emulation(aihead);
       gai_free(canon);
       socket_ops::freehostent(hptr);
       return EAI_FAMILY;
     }
@@ -2701,23 +3002,23 @@ inline boost::system::error_code getnameinfo_emulation(
 
   const char* addr;
   size_t addr_len;
   unsigned short port;
   switch (sa->sa_family)
   {
-  case AF_INET:
+  case BOOST_ASIO_OS_DEF(AF_INET):
     if (salen != sizeof(sockaddr_in4_type))
     {
       return ec = boost::asio::error::invalid_argument;
     }
     addr = reinterpret_cast<const char*>(
         &reinterpret_cast<const sockaddr_in4_type*>(sa)->sin_addr);
     addr_len = sizeof(in4_addr_type);
     port = reinterpret_cast<const sockaddr_in4_type*>(sa)->sin_port;
     break;
-  case AF_INET6:
+  case BOOST_ASIO_OS_DEF(AF_INET6):
     if (salen != sizeof(sockaddr_in6_type))
     {
       return ec = boost::asio::error::invalid_argument;
     }
     addr = reinterpret_cast<const char*>(
         &reinterpret_cast<const sockaddr_in6_type*>(sa)->sin6_addr);
@@ -2778,57 +3079,52 @@ inline boost::system::error_code getnameinfo_emulation(
     if (flags & NI_NUMERICSERV)
     {
       if (servlen < 6)
       {
         return ec = boost::asio::error::no_buffer_space;
       }
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) && !defined(UNDER_CE)
+#if defined(BOOST_ASIO_HAS_SECURE_RTL)
       sprintf_s(serv, servlen, "%u", ntohs(port));
-#else
+#else // defined(BOOST_ASIO_HAS_SECURE_RTL)
       sprintf(serv, "%u", ntohs(port));
-#endif
+#endif // defined(BOOST_ASIO_HAS_SECURE_RTL)
     }
     else
     {
-#if defined(BOOST_HAS_THREADS) && defined(BOOST_HAS_PTHREADS) \
-      && !defined(BOOST_ASIO_DISABLE_THREADS)
+#if defined(BOOST_ASIO_HAS_PTHREADS)
       static ::pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
       ::pthread_mutex_lock(&mutex);
-#endif // defined(BOOST_HAS_THREADS) && defined(BOOST_HAS_PTHREADS)
-       //   && !defined(BOOST_ASIO_DISABLE_THREADS)
+#endif // defined(BOOST_ASIO_HAS_PTHREADS)
       servent* sptr = ::getservbyport(port, (flags & NI_DGRAM) ? "udp" : 0);
       if (sptr && sptr->s_name && sptr->s_name[0] != '\0')
       {
         gai_strcpy(serv, sptr->s_name, servlen);
       }
       else
       {
         if (servlen < 6)
         {
           return ec = boost::asio::error::no_buffer_space;
         }
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) && !defined(UNDER_CE)
+#if defined(BOOST_ASIO_HAS_SECURE_RTL)
         sprintf_s(serv, servlen, "%u", ntohs(port));
-#else
+#else // defined(BOOST_ASIO_HAS_SECURE_RTL)
         sprintf(serv, "%u", ntohs(port));
-#endif
+#endif // defined(BOOST_ASIO_HAS_SECURE_RTL)
       }
-#if defined(BOOST_HAS_THREADS) && defined(BOOST_HAS_PTHREADS) \
-      && !defined(BOOST_ASIO_DISABLE_THREADS)
+#if defined(BOOST_ASIO_HAS_PTHREADS)
       ::pthread_mutex_unlock(&mutex);
-#endif // defined(BOOST_HAS_THREADS) && defined(BOOST_HAS_PTHREADS)
-       //   && !defined(BOOST_ASIO_DISABLE_THREADS)
+#endif // defined(BOOST_ASIO_HAS_PTHREADS)
     }
   }
 
   ec = boost::system::error_code();
   return ec;
 }
 
-#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
-       //   || defined(__MACH__) && defined(__APPLE__)
+#endif // !defined(BOOST_ASIO_HAS_GETADDRINFO)
 
 inline boost::system::error_code translate_addrinfo_error(int error)
 {
   switch (error)
   {
   case 0:
@@ -2853,13 +3149,13 @@ inline boost::system::error_code translate_addrinfo_error(int error)
     return boost::asio::error::host_not_found;
   case EAI_SERVICE:
     return boost::asio::error::service_not_found;
   case EAI_SOCKTYPE:
     return boost::asio::error::socket_type_not_supported;
   default: // Possibly the non-portable EAI_SYSTEM.
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
     return boost::system::error_code(
         WSAGetLastError(), boost::asio::error::get_system_category());
 #else
     return boost::system::error_code(
         errno, boost::asio::error::get_system_category());
 #endif
@@ -2870,14 +3166,14 @@ boost::system::error_code getaddrinfo(const char* host,
     const char* service, const addrinfo_type& hints,
     addrinfo_type** result, boost::system::error_code& ec)
 {
   host = (host && *host) ? host : 0;
   service = (service && *service) ? service : 0;
   clear_last_error();
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
-# if defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0501) || defined(UNDER_CE)
+#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
+# if defined(BOOST_ASIO_HAS_GETADDRINFO)
   // Building for Windows XP, Windows Server 2003, or later.
   int error = ::getaddrinfo(host, service, &hints, result);
   return ec = translate_addrinfo_error(error);
 # else
   // Building for Windows 2000 or earlier.
   typedef int (WSAAPI *gai_t)(const char*,
@@ -2890,13 +3186,13 @@ boost::system::error_code getaddrinfo(const char* host,
       return ec = translate_addrinfo_error(error);
     }
   }
   int error = getaddrinfo_emulation(host, service, &hints, result);
   return ec = translate_addrinfo_error(error);
 # endif
-#elif defined(__MACH__) && defined(__APPLE__)
+#elif !defined(BOOST_ASIO_HAS_GETADDRINFO)
   int error = getaddrinfo_emulation(host, service, &hints, result);
   return ec = translate_addrinfo_error(error);
 #else
   int error = ::getaddrinfo(host, service, &hints, result);
   return ec = translate_addrinfo_error(error);
 #endif
@@ -2913,14 +3209,14 @@ boost::system::error_code background_getaddrinfo(
     socket_ops::getaddrinfo(host, service, hints, result, ec);
   return ec;
 }
 
 void freeaddrinfo(addrinfo_type* ai)
 {
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
-# if defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0501) || defined(UNDER_CE)
+#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
+# if defined(BOOST_ASIO_HAS_GETADDRINFO)
   // Building for Windows XP, Windows Server 2003, or later.
   ::freeaddrinfo(ai);
 # else
   // Building for Windows 2000 or earlier.
   typedef int (WSAAPI *fai_t)(addrinfo_type*);
   if (HMODULE winsock_module = ::GetModuleHandleA("ws2_32"))
@@ -2930,25 +3226,25 @@ void freeaddrinfo(addrinfo_type* ai)
       fai(ai);
       return;
     }
   }
   freeaddrinfo_emulation(ai);
 # endif
-#elif defined(__MACH__) && defined(__APPLE__)
+#elif !defined(BOOST_ASIO_HAS_GETADDRINFO)
   freeaddrinfo_emulation(ai);
 #else
   ::freeaddrinfo(ai);
 #endif
 }
 
 boost::system::error_code getnameinfo(const socket_addr_type* addr,
     std::size_t addrlen, char* host, std::size_t hostlen,
     char* serv, std::size_t servlen, int flags, boost::system::error_code& ec)
 {
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
-# if defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0501) || defined(UNDER_CE)
+#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
+# if defined(BOOST_ASIO_HAS_GETADDRINFO)
   // Building for Windows XP, Windows Server 2003, or later.
   clear_last_error();
   int error = ::getnameinfo(addr, static_cast<socklen_t>(addrlen),
       host, static_cast<DWORD>(hostlen),
       serv, static_cast<DWORD>(servlen), flags);
   return ec = translate_addrinfo_error(error);
@@ -2968,13 +3264,13 @@ boost::system::error_code getnameinfo(const socket_addr_type* addr,
     }
   }
   clear_last_error();
   return getnameinfo_emulation(addr, addrlen,
       host, hostlen, serv, servlen, flags, ec);
 # endif
-#elif defined(__MACH__) && defined(__APPLE__)
+#elif !defined(BOOST_ASIO_HAS_GETADDRINFO)
   using namespace std; // For memcpy.
   sockaddr_storage_type tmp_addr;
   memcpy(&tmp_addr, addr, addrlen);
   tmp_addr.ss_len = addrlen;
   addr = reinterpret_cast<socket_addr_type*>(&tmp_addr);
   clear_last_error();
@@ -3030,30 +3326,66 @@ boost::system::error_code background_getnameinfo(
     }
   }
 
   return ec;
 }
 
+#endif // !defined(BOOST_ASIO_WINDOWS_RUNTIME)
+
 u_long_type network_to_host_long(u_long_type value)
 {
+#if defined(BOOST_ASIO_WINDOWS_RUNTIME)
+  unsigned char* value_p = reinterpret_cast<unsigned char*>(&value);
+  u_long_type result = (static_cast<u_long_type>(value_p[0]) << 24)
+    | (static_cast<u_long_type>(value_p[1]) << 16)
+    | (static_cast<u_long_type>(value_p[2]) << 8)
+    | static_cast<u_long_type>(value_p[3]);
+  return result;
+#else // defined(BOOST_ASIO_WINDOWS_RUNTIME)
   return ntohl(value);
+#endif // defined(BOOST_ASIO_WINDOWS_RUNTIME)
 }
 
 u_long_type host_to_network_long(u_long_type value)
 {
+#if defined(BOOST_ASIO_WINDOWS_RUNTIME)
+  u_long_type result;
+  unsigned char* result_p = reinterpret_cast<unsigned char*>(&result);
+  result_p[0] = static_cast<unsigned char>((value >> 24) & 0xFF);
+  result_p[1] = static_cast<unsigned char>((value >> 16) & 0xFF);
+  result_p[2] = static_cast<unsigned char>((value >> 8) & 0xFF);
+  result_p[3] = static_cast<unsigned char>(value & 0xFF);
+  return result;
+#else // defined(BOOST_ASIO_WINDOWS_RUNTIME)
   return htonl(value);
+#endif // defined(BOOST_ASIO_WINDOWS_RUNTIME)
 }
 
 u_short_type network_to_host_short(u_short_type value)
 {
+#if defined(BOOST_ASIO_WINDOWS_RUNTIME)
+  unsigned char* value_p = reinterpret_cast<unsigned char*>(&value);
+  u_short_type result = (static_cast<u_long_type>(value_p[0]) << 8)
+    | static_cast<u_long_type>(value_p[1]);
+  return result;
+#else // defined(BOOST_ASIO_WINDOWS_RUNTIME)
   return ntohs(value);
+#endif // defined(BOOST_ASIO_WINDOWS_RUNTIME)
 }
 
 u_short_type host_to_network_short(u_short_type value)
 {
+#if defined(BOOST_ASIO_WINDOWS_RUNTIME)
+  u_long_type result;
+  unsigned char* result_p = reinterpret_cast<unsigned char*>(&result);
+  result_p[0] = static_cast<unsigned char>((value >> 8) & 0xFF);
+  result_p[1] = static_cast<unsigned char>(value & 0xFF);
+  return result;
+#else // defined(BOOST_ASIO_WINDOWS_RUNTIME)
   return htons(value);
+#endif // defined(BOOST_ASIO_WINDOWS_RUNTIME)
 }
 
 } // namespace socket_ops
 } // namespace detail
 } // namespace asio
 } // namespace boost
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/socket_select_interrupter.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/socket_select_interrupter.ipp
index 6005f12..e2dedc7 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/socket_select_interrupter.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/socket_select_interrupter.ipp
@@ -1,11 +1,11 @@
 //
 // detail/impl/socket_select_interrupter.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_IMPL_SOCKET_SELECT_INTERRUPTER_IPP
@@ -14,13 +14,15 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
-#if defined(BOOST_WINDOWS) \
+#if !defined(BOOST_ASIO_WINDOWS_RUNTIME)
+
+#if defined(BOOST_ASIO_WINDOWS) \
   || defined(__CYGWIN__) \
   || defined(__SYMBIAN32__)
 
 #include <cstdlib>
 #include <boost/asio/detail/socket_holder.hpp>
 #include <boost/asio/detail/socket_ops.hpp>
@@ -54,26 +56,26 @@ void socket_select_interrupter::open_descriptors()
 
   using namespace std; // For memset.
   sockaddr_in4_type addr;
   std::size_t addr_len = sizeof(addr);
   memset(&addr, 0, sizeof(addr));
   addr.sin_family = AF_INET;
-  addr.sin_addr.s_addr = inet_addr("127.0.0.1");
+  addr.sin_addr.s_addr = socket_ops::host_to_network_long(INADDR_LOOPBACK);
   addr.sin_port = 0;
   if (socket_ops::bind(acceptor.get(), (const socket_addr_type*)&addr,
         addr_len, ec) == socket_error_retval)
     boost::asio::detail::throw_error(ec, "socket_select_interrupter");
 
   if (socket_ops::getsockname(acceptor.get(), (socket_addr_type*)&addr,
         &addr_len, ec) == socket_error_retval)
     boost::asio::detail::throw_error(ec, "socket_select_interrupter");
 
   // Some broken firewalls on Windows will intermittently cause getsockname to
   // return 0.0.0.0 when the socket is actually bound to 127.0.0.1. We
   // explicitly specify the target address here to work around this problem.
-  addr.sin_addr.s_addr = inet_addr("127.0.0.1");
+  addr.sin_addr.s_addr = socket_ops::host_to_network_long(INADDR_LOOPBACK);
 
   if (socket_ops::listen(acceptor.get(),
         SOMAXCONN, ec) == socket_error_retval)
     boost::asio::detail::throw_error(ec, "socket_select_interrupter");
 
   socket_holder client(socket_ops::socket(
@@ -163,11 +165,13 @@ bool socket_select_interrupter::reset()
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
-#endif // defined(BOOST_WINDOWS)
+#endif // defined(BOOST_ASIO_WINDOWS)
        // || defined(__CYGWIN__)
        // || defined(__SYMBIAN32__)
 
+#endif // !defined(BOOST_ASIO_WINDOWS_RUNTIME)
+
 #endif // BOOST_ASIO_DETAIL_IMPL_SOCKET_SELECT_INTERRUPTER_IPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/strand_service.hpp b/3rdParty/Boost/src/boost/asio/detail/impl/strand_service.hpp
index 7581852..17227f9 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/strand_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/strand_service.hpp
@@ -1,23 +1,24 @@
 //
 // detail/impl/strand_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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_IMPL_STRAND_SERVICE_HPP
 #define BOOST_ASIO_DETAIL_IMPL_STRAND_SERVICE_HPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
+#include <boost/asio/detail/addressof.hpp>
 #include <boost/asio/detail/call_stack.hpp>
 #include <boost/asio/detail/completion_handler.hpp>
 #include <boost/asio/detail/fenced_block.hpp>
 #include <boost/asio/detail/handler_alloc_helpers.hpp>
 #include <boost/asio/detail/handler_invoke_helpers.hpp>
 
@@ -43,31 +44,31 @@ struct strand_service::on_dispatch_exit
     impl_->mutex_.lock();
     impl_->ready_queue_.push(impl_->waiting_queue_);
     bool more_handlers = impl_->locked_ = !impl_->ready_queue_.empty();
     impl_->mutex_.unlock();
 
     if (more_handlers)
-      io_service_->post_immediate_completion(impl_);
+      io_service_->post_immediate_completion(impl_, false);
   }
 };
 
 template <typename Handler>
 void strand_service::dispatch(strand_service::implementation_type& impl,
-    Handler handler)
+    Handler& handler)
 {
   // If we are already in the strand then the handler can run immediately.
   if (call_stack<strand_impl>::contains(impl))
   {
     fenced_block b(fenced_block::full);
     boost_asio_handler_invoke_helpers::invoke(handler, handler);
     return;
   }
 
   // Allocate and construct an operation to wrap the handler.
   typedef completion_handler<Handler> op;
-  typename op::ptr p = { boost::addressof(handler),
+  typename op::ptr p = { boost::asio::detail::addressof(handler),
     boost_asio_handler_alloc_helpers::allocate(
       sizeof(op), handler), 0 };
   p.p = new (p.v) op(handler);
 
   BOOST_ASIO_HANDLER_CREATION((p.p, "strand", impl, "dispatch"));
 
@@ -89,24 +90,27 @@ void strand_service::dispatch(strand_service::implementation_type& impl,
   }
 }
 
 // Request the io_service to invoke the given handler and return immediately.
 template <typename Handler>
 void strand_service::post(strand_service::implementation_type& impl,
-    Handler handler)
+    Handler& handler)
 {
+  bool is_continuation =
+    boost_asio_handler_cont_helpers::is_continuation(handler);
+
   // Allocate and construct an operation to wrap the handler.
   typedef completion_handler<Handler> op;
-  typename op::ptr p = { boost::addressof(handler),
+  typename op::ptr p = { boost::asio::detail::addressof(handler),
     boost_asio_handler_alloc_helpers::allocate(
       sizeof(op), handler), 0 };
   p.p = new (p.v) op(handler);
 
   BOOST_ASIO_HANDLER_CREATION((p.p, "strand", impl, "post"));
 
-  do_post(impl, p.p);
+  do_post(impl, p.p, is_continuation);
   p.v = p.p = 0;
 }
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/strand_service.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/strand_service.ipp
index 1912d80..9af0128 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/strand_service.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/strand_service.ipp
@@ -1,11 +1,11 @@
 //
 // detail/impl/strand_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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_IMPL_STRAND_SERVICE_IPP
@@ -35,13 +35,13 @@ struct strand_service::on_do_complete_exit
     impl_->mutex_.lock();
     impl_->ready_queue_.push(impl_->waiting_queue_);
     bool more_handlers = impl_->locked_ = !impl_->ready_queue_.empty();
     impl_->mutex_.unlock();
 
     if (more_handlers)
-      owner_->post_private_immediate_completion(impl_);
+      owner_->post_immediate_completion(impl_, true);
   }
 };
 
 strand_service::strand_service(boost::asio::io_service& io_service)
   : boost::asio::detail::service_base<strand_service>(io_service),
     io_service_(boost::asio::use_service<io_service_impl>(io_service)),
@@ -82,12 +82,18 @@ void strand_service::construct(strand_service::implementation_type& impl)
 
   if (!implementations_[index].get())
     implementations_[index].reset(new strand_impl);
   impl = implementations_[index].get();
 }
 
+bool strand_service::running_in_this_thread(
+    const implementation_type& impl) const
+{
+  return call_stack<strand_impl>::contains(impl) != 0;
+}
+
 bool strand_service::do_dispatch(implementation_type& impl, operation* op)
 {
   // If we are running inside the io_service, and no other handler already
   // holds the strand lock, then the handler can run immediately.
   bool can_dispatch = io_service_.can_dispatch();
   impl->mutex_.lock();
@@ -109,19 +115,20 @@ bool strand_service::do_dispatch(implementation_type& impl, operation* op)
   {
     // The handler is acquiring the strand lock and so is responsible for
     // scheduling the strand.
     impl->locked_ = true;
     impl->mutex_.unlock();
     impl->ready_queue_.push(op);
-    io_service_.post_immediate_completion(impl);
+    io_service_.post_immediate_completion(impl, false);
   }
 
   return false;
 }
 
-void strand_service::do_post(implementation_type& impl, operation* op)
+void strand_service::do_post(implementation_type& impl,
+    operation* op, bool is_continuation)
 {
   impl->mutex_.lock();
   if (impl->locked_)
   {
     // Some other handler already holds the strand lock. Enqueue for later.
     impl->waiting_queue_.push(op);
@@ -131,13 +138,13 @@ void strand_service::do_post(implementation_type& impl, operation* op)
   {
     // The handler is acquiring the strand lock and so is responsible for
     // scheduling the strand.
     impl->locked_ = true;
     impl->mutex_.unlock();
     impl->ready_queue_.push(op);
-    io_service_.post_immediate_completion(impl);
+    io_service_.post_immediate_completion(impl, is_continuation);
   }
 }
 
 void strand_service::do_complete(io_service_impl* owner, operation* base,
     const boost::system::error_code& ec, std::size_t /*bytes_transferred*/)
 {
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/task_io_service.hpp b/3rdParty/Boost/src/boost/asio/detail/impl/task_io_service.hpp
index 2cc7b7e..4312de7 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/task_io_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/task_io_service.hpp
@@ -1,71 +1,76 @@
 //
 // detail/impl/task_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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_IMPL_TASK_IO_SERVICE_HPP
 #define BOOST_ASIO_DETAIL_IMPL_TASK_IO_SERVICE_HPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
+#include <boost/asio/detail/addressof.hpp>
 #include <boost/asio/detail/completion_handler.hpp>
 #include <boost/asio/detail/fenced_block.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/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 template <typename Handler>
-void task_io_service::dispatch(Handler handler)
+void task_io_service::dispatch(Handler& handler)
 {
   if (thread_call_stack::contains(this))
   {
     fenced_block b(fenced_block::full);
     boost_asio_handler_invoke_helpers::invoke(handler, handler);
   }
   else
   {
     // Allocate and construct an operation to wrap the handler.
     typedef completion_handler<Handler> op;
-    typename op::ptr p = { boost::addressof(handler),
+    typename op::ptr p = { boost::asio::detail::addressof(handler),
       boost_asio_handler_alloc_helpers::allocate(
         sizeof(op), handler), 0 };
     p.p = new (p.v) op(handler);
 
     BOOST_ASIO_HANDLER_CREATION((p.p, "io_service", this, "dispatch"));
 
-    post_non_private_immediate_completion(p.p);
+    do_dispatch(p.p);
     p.v = p.p = 0;
   }
 }
 
 template <typename Handler>
-void task_io_service::post(Handler handler)
+void task_io_service::post(Handler& handler)
 {
+  bool is_continuation =
+    boost_asio_handler_cont_helpers::is_continuation(handler);
+
   // Allocate and construct an operation to wrap the handler.
   typedef completion_handler<Handler> op;
-  typename op::ptr p = { boost::addressof(handler),
+  typename op::ptr p = { boost::asio::detail::addressof(handler),
     boost_asio_handler_alloc_helpers::allocate(
       sizeof(op), handler), 0 };
   p.p = new (p.v) op(handler);
 
   BOOST_ASIO_HANDLER_CREATION((p.p, "io_service", this, "post"));
 
-  post_immediate_completion(p.p);
+  post_immediate_completion(p.p, is_continuation);
   p.v = p.p = 0;
 }
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/task_io_service.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/task_io_service.ipp
index 674df63..e58e11e 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/task_io_service.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/task_io_service.ipp
@@ -1,11 +1,11 @@
 //
 // detail/impl/task_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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_IMPL_TASK_IO_SERVICE_IPP
@@ -16,31 +16,24 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
 #if !defined(BOOST_ASIO_HAS_IOCP)
 
-#include <boost/limits.hpp>
 #include <boost/asio/detail/event.hpp>
+#include <boost/asio/detail/limits.hpp>
 #include <boost/asio/detail/reactor.hpp>
 #include <boost/asio/detail/task_io_service.hpp>
+#include <boost/asio/detail/task_io_service_thread_info.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
-struct task_io_service::thread_info
-{
-  event* wakeup_event;
-  op_queue<operation> private_op_queue;
-  long private_outstanding_work;
-  thread_info* next;
-};
-
 struct task_io_service::task_cleanup
 {
   ~task_cleanup()
   {
     if (this_thread_->private_outstanding_work > 0)
     {
@@ -76,19 +69,19 @@ struct task_io_service::work_cleanup
     else if (this_thread_->private_outstanding_work < 1)
     {
       task_io_service_->work_finished();
     }
     this_thread_->private_outstanding_work = 0;
 
-#if defined(BOOST_HAS_THREADS) && !defined(BOOST_ASIO_DISABLE_THREADS)
+#if defined(BOOST_ASIO_HAS_THREADS)
     if (!this_thread_->private_op_queue.empty())
     {
       lock_->lock();
       task_io_service_->op_queue_.push(this_thread_->private_op_queue);
     }
-#endif // defined(BOOST_HAS_THREADS) && !defined(BOOST_ASIO_DISABLE_THREADS)
+#endif // defined(BOOST_ASIO_HAS_THREADS)
   }
 
   task_io_service* task_io_service_;
   mutex::scoped_lock* lock_;
   thread_info* this_thread_;
 };
@@ -99,14 +92,13 @@ task_io_service::task_io_service(
     one_thread_(concurrency_hint == 1),
     mutex_(),
     task_(0),
     task_interrupted_(true),
     outstanding_work_(0),
     stopped_(false),
-    shutdown_(false),
-    first_idle_thread_(0)
+    shutdown_(false)
 {
   BOOST_ASIO_HANDLER_TRACKING_INIT;
 }
 
 void task_io_service::shutdown_service()
 {
@@ -145,16 +137,13 @@ std::size_t task_io_service::run(boost::system::error_code& ec)
   {
     stop();
     return 0;
   }
 
   thread_info this_thread;
-  event wakeup_event;
-  this_thread.wakeup_event = &wakeup_event;
   this_thread.private_outstanding_work = 0;
-  this_thread.next = 0;
   thread_call_stack::context ctx(this, this_thread);
 
   mutex::scoped_lock lock(mutex_);
 
   std::size_t n = 0;
   for (; do_run_one(lock, this_thread, ec); lock.lock())
@@ -170,16 +159,13 @@ std::size_t task_io_service::run_one(boost::system::error_code& ec)
   {
     stop();
     return 0;
   }
 
   thread_info this_thread;
-  event wakeup_event;
-  this_thread.wakeup_event = &wakeup_event;
   this_thread.private_outstanding_work = 0;
-  this_thread.next = 0;
   thread_call_stack::context ctx(this, this_thread);
 
   mutex::scoped_lock lock(mutex_);
 
   return do_run_one(lock, this_thread, ec);
 }
@@ -191,27 +177,25 @@ std::size_t task_io_service::poll(boost::system::error_code& ec)
   {
     stop();
     return 0;
   }
 
   thread_info this_thread;
-  this_thread.wakeup_event = 0;
   this_thread.private_outstanding_work = 0;
-  this_thread.next = 0;
   thread_call_stack::context ctx(this, this_thread);
 
   mutex::scoped_lock lock(mutex_);
 
-#if defined(BOOST_HAS_THREADS) && !defined(BOOST_ASIO_DISABLE_THREADS)
+#if defined(BOOST_ASIO_HAS_THREADS)
   // We want to support nested calls to poll() and poll_one(), so any handlers
   // that are already on a thread-private queue need to be put on to the main
   // queue now.
   if (one_thread_)
     if (thread_info* outer_thread_info = ctx.next_by_key())
       op_queue_.push(outer_thread_info->private_op_queue);
-#endif // defined(BOOST_HAS_THREADS) && !defined(BOOST_ASIO_DISABLE_THREADS)
+#endif // defined(BOOST_ASIO_HAS_THREADS)
 
   std::size_t n = 0;
   for (; do_poll_one(lock, this_thread, ec); lock.lock())
     if (n != (std::numeric_limits<std::size_t>::max)())
       ++n;
   return n;
@@ -224,27 +208,25 @@ std::size_t task_io_service::poll_one(boost::system::error_code& ec)
   {
     stop();
     return 0;
   }
 
   thread_info this_thread;
-  this_thread.wakeup_event = 0;
   this_thread.private_outstanding_work = 0;
-  this_thread.next = 0;
   thread_call_stack::context ctx(this, this_thread);
 
   mutex::scoped_lock lock(mutex_);
 
-#if defined(BOOST_HAS_THREADS) && !defined(BOOST_ASIO_DISABLE_THREADS)
+#if defined(BOOST_ASIO_HAS_THREADS)
   // We want to support nested calls to poll() and poll_one(), so any handlers
   // that are already on a thread-private queue need to be put on to the main
   // queue now.
   if (one_thread_)
     if (thread_info* outer_thread_info = ctx.next_by_key())
       op_queue_.push(outer_thread_info->private_op_queue);
-#endif // defined(BOOST_HAS_THREADS) && !defined(BOOST_ASIO_DISABLE_THREADS)
+#endif // defined(BOOST_ASIO_HAS_THREADS)
 
   return do_poll_one(lock, this_thread, ec);
 }
 
 void task_io_service::stop()
 {
@@ -261,105 +243,79 @@ bool task_io_service::stopped() const
 void task_io_service::reset()
 {
   mutex::scoped_lock lock(mutex_);
   stopped_ = false;
 }
 
-void task_io_service::post_immediate_completion(task_io_service::operation* op)
+void task_io_service::post_immediate_completion(
+    task_io_service::operation* op, bool is_continuation)
 {
-#if defined(BOOST_HAS_THREADS) && !defined(BOOST_ASIO_DISABLE_THREADS)
-  if (one_thread_)
+#if defined(BOOST_ASIO_HAS_THREADS)
+  if (one_thread_ || is_continuation)
   {
     if (thread_info* this_thread = thread_call_stack::contains(this))
     {
       ++this_thread->private_outstanding_work;
       this_thread->private_op_queue.push(op);
       return;
     }
   }
-#endif // defined(BOOST_HAS_THREADS) && !defined(BOOST_ASIO_DISABLE_THREADS)
+#else // defined(BOOST_ASIO_HAS_THREADS)
+  (void)is_continuation;
+#endif // defined(BOOST_ASIO_HAS_THREADS)
 
   work_started();
   mutex::scoped_lock lock(mutex_);
   op_queue_.push(op);
   wake_one_thread_and_unlock(lock);
 }
 
 void task_io_service::post_deferred_completion(task_io_service::operation* op)
 {
-#if defined(BOOST_HAS_THREADS) && !defined(BOOST_ASIO_DISABLE_THREADS)
+#if defined(BOOST_ASIO_HAS_THREADS)
   if (one_thread_)
   {
     if (thread_info* this_thread = thread_call_stack::contains(this))
     {
       this_thread->private_op_queue.push(op);
       return;
     }
   }
-#endif // defined(BOOST_HAS_THREADS) && !defined(BOOST_ASIO_DISABLE_THREADS)
+#endif // defined(BOOST_ASIO_HAS_THREADS)
 
   mutex::scoped_lock lock(mutex_);
   op_queue_.push(op);
   wake_one_thread_and_unlock(lock);
 }
 
 void task_io_service::post_deferred_completions(
     op_queue<task_io_service::operation>& ops)
 {
   if (!ops.empty())
   {
-#if defined(BOOST_HAS_THREADS) && !defined(BOOST_ASIO_DISABLE_THREADS)
+#if defined(BOOST_ASIO_HAS_THREADS)
     if (one_thread_)
     {
       if (thread_info* this_thread = thread_call_stack::contains(this))
       {
         this_thread->private_op_queue.push(ops);
         return;
       }
     }
-#endif // defined(BOOST_HAS_THREADS) && !defined(BOOST_ASIO_DISABLE_THREADS)
+#endif // defined(BOOST_ASIO_HAS_THREADS)
 
     mutex::scoped_lock lock(mutex_);
     op_queue_.push(ops);
     wake_one_thread_and_unlock(lock);
   }
 }
 
-void task_io_service::post_private_immediate_completion(
-    task_io_service::operation* op)
-{
-  work_started();
-  post_private_deferred_completion(op);
-}
-
-void task_io_service::post_private_deferred_completion(
-    task_io_service::operation* op)
-{
-#if defined(BOOST_HAS_THREADS) && !defined(BOOST_ASIO_DISABLE_THREADS)
-  if (thread_info* this_thread = thread_call_stack::contains(this))
-  {
-    this_thread->private_op_queue.push(op);
-    return;
-  }
-#endif // defined(BOOST_HAS_THREADS) && !defined(BOOST_ASIO_DISABLE_THREADS)
-
-  mutex::scoped_lock lock(mutex_);
-  op_queue_.push(op);
-  wake_one_thread_and_unlock(lock);
-}
-
-void task_io_service::post_non_private_immediate_completion(
+void task_io_service::do_dispatch(
     task_io_service::operation* op)
 {
   work_started();
-  post_non_private_deferred_completion(op);
-}
-
-void task_io_service::post_non_private_deferred_completion(
-    task_io_service::operation* op)
-{
   mutex::scoped_lock lock(mutex_);
   op_queue_.push(op);
   wake_one_thread_and_unlock(lock);
 }
 
 void task_io_service::abandon_operations(
@@ -384,16 +340,13 @@ std::size_t task_io_service::do_run_one(mutex::scoped_lock& lock,
 
       if (o == &task_operation_)
       {
         task_interrupted_ = more_handlers;
 
         if (more_handlers && !one_thread_)
-        {
-          if (!wake_one_idle_thread_and_unlock(lock))
-            lock.unlock();
-        }
+          wakeup_event_.unlock_and_signal_one(lock);
         else
           lock.unlock();
 
         task_cleanup on_exit = { this, &lock, &this_thread };
         (void)on_exit;
 
@@ -420,17 +373,14 @@ std::size_t task_io_service::do_run_one(mutex::scoped_lock& lock,
 
         return 1;
       }
     }
     else
     {
-      // Nothing to run right now, so just wait for work to do.
-      this_thread.next = first_idle_thread_;
-      first_idle_thread_ = &this_thread;
-      this_thread.wakeup_event->clear(lock);
-      this_thread.wakeup_event->wait(lock);
+      wakeup_event_.clear(lock);
+      wakeup_event_.wait(lock);
     }
   }
 
   return 0;
 }
 
@@ -456,13 +406,16 @@ std::size_t task_io_service::do_poll_one(mutex::scoped_lock& lock,
       // as soon as possible.
       task_->run(false, this_thread.private_op_queue);
     }
 
     o = op_queue_.front();
     if (o == &task_operation_)
+    {
+      wakeup_event_.maybe_unlock_and_signal_one(lock);
       return 0;
+    }
   }
 
   if (o == 0)
     return 0;
 
   op_queue_.pop();
@@ -486,46 +439,25 @@ std::size_t task_io_service::do_poll_one(mutex::scoped_lock& lock,
 }
 
 void task_io_service::stop_all_threads(
     mutex::scoped_lock& lock)
 {
   stopped_ = true;
-
-  while (first_idle_thread_)
-  {
-    thread_info* idle_thread = first_idle_thread_;
-    first_idle_thread_ = idle_thread->next;
-    idle_thread->next = 0;
-    idle_thread->wakeup_event->signal(lock);
-  }
+  wakeup_event_.signal_all(lock);
 
   if (!task_interrupted_ && task_)
   {
     task_interrupted_ = true;
     task_->interrupt();
   }
 }
 
-bool task_io_service::wake_one_idle_thread_and_unlock(
-    mutex::scoped_lock& lock)
-{
-  if (first_idle_thread_)
-  {
-    thread_info* idle_thread = first_idle_thread_;
-    first_idle_thread_ = idle_thread->next;
-    idle_thread->next = 0;
-    idle_thread->wakeup_event->signal_and_unlock(lock);
-    return true;
-  }
-  return false;
-}
-
 void task_io_service::wake_one_thread_and_unlock(
     mutex::scoped_lock& lock)
 {
-  if (!wake_one_idle_thread_and_unlock(lock))
+  if (!wakeup_event_.maybe_unlock_and_signal_one(lock))
   {
     if (!task_interrupted_ && task_)
     {
       task_interrupted_ = true;
       task_->interrupt();
     }
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/throw_error.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/throw_error.ipp
index dbe6112..5f6ed39 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/throw_error.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/throw_error.ipp
@@ -1,11 +1,11 @@
 //
 // detail/impl/throw_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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_IMPL_THROW_ERROR_IPP
@@ -13,32 +13,32 @@
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
-#include <boost/throw_exception.hpp>
 #include <boost/asio/detail/throw_error.hpp>
+#include <boost/asio/detail/throw_exception.hpp>
 #include <boost/system/system_error.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 void do_throw_error(const boost::system::error_code& err)
 {
   boost::system::system_error e(err);
-  boost::throw_exception(e);
+  boost::asio::detail::throw_exception(e);
 }
 
 void do_throw_error(const boost::system::error_code& err, const char* location)
 {
   boost::system::system_error e(err, location);
-  boost::throw_exception(e);
+  boost::asio::detail::throw_exception(e);
 }
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/timer_queue_ptime.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/timer_queue_ptime.ipp
index c72d885..3b16def 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/timer_queue_ptime.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/timer_queue_ptime.ipp
@@ -1,11 +1,11 @@
 //
 // detail/impl/timer_queue_ptime.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_IMPL_TIMER_QUEUE_PTIME_IPP
@@ -17,12 +17,14 @@
 
 #include <boost/asio/detail/config.hpp>
 #include <boost/asio/detail/timer_queue_ptime.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
+#if defined(BOOST_ASIO_HAS_BOOST_DATE_TIME)
+
 namespace boost {
 namespace asio {
 namespace detail {
 
 timer_queue<time_traits<boost::posix_time::ptime> >::timer_queue()
 {
@@ -74,9 +76,11 @@ std::size_t timer_queue<time_traits<boost::posix_time::ptime> >::cancel_timer(
 }
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
+#endif // defined(BOOST_ASIO_HAS_BOOST_DATE_TIME)
+
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // BOOST_ASIO_DETAIL_IMPL_TIMER_QUEUE_PTIME_IPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/timer_queue_set.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/timer_queue_set.ipp
index 7f9a662..19b770b 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/timer_queue_set.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/timer_queue_set.ipp
@@ -1,11 +1,11 @@
 //
 // detail/impl/timer_queue_set.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_IMPL_TIMER_QUEUE_SET_IPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/win_event.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/win_event.ipp
index 252242c..a004c09 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/win_event.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/win_event.ipp
@@ -1,11 +1,11 @@
 //
 // detail/win_event.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_IMPL_WIN_EVENT_IPP
@@ -14,39 +14,56 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
-#if defined(BOOST_WINDOWS)
+#if defined(BOOST_ASIO_WINDOWS)
 
 #include <boost/asio/detail/throw_error.hpp>
 #include <boost/asio/detail/win_event.hpp>
 #include <boost/asio/error.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 win_event::win_event()
-  : event_(::CreateEvent(0, true, false, 0))
+  : state_(0)
 {
-  if (!event_)
+  events_[0] = ::CreateEvent(0, true, false, 0);
+  if (!events_[0])
   {
     DWORD last_error = ::GetLastError();
     boost::system::error_code ec(last_error,
         boost::asio::error::get_system_category());
     boost::asio::detail::throw_error(ec, "event");
   }
+
+  events_[1] = ::CreateEvent(0, false, false, 0);
+  if (!events_[1])
+  {
+    DWORD last_error = ::GetLastError();
+    ::CloseHandle(events_[0]);
+    boost::system::error_code ec(last_error,
+        boost::asio::error::get_system_category());
+    boost::asio::detail::throw_error(ec, "event");
+  }
+}
+
+win_event::~win_event()
+{
+  ::CloseHandle(events_[0]);
+  ::CloseHandle(events_[1]);
 }
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
-#endif // defined(BOOST_WINDOWS)
+#endif // defined(BOOST_ASIO_WINDOWS)
 
 #endif // BOOST_ASIO_DETAIL_IMPL_WIN_EVENT_IPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/win_iocp_handle_service.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/win_iocp_handle_service.ipp
index ecd45c0..04a6791 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/win_iocp_handle_service.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/win_iocp_handle_service.ipp
@@ -1,11 +1,11 @@
 //
 // detail/impl/win_iocp_handle_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)
 // Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.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)
 //
 
@@ -43,13 +43,14 @@ public:
     hEvent = ::CreateEvent(0, TRUE, FALSE, 0);
     if (hEvent)
     {
       // As documented in GetQueuedCompletionStatus, setting the low order
       // bit of this event prevents our synchronous writes from being treated
       // as completion port events.
-      *reinterpret_cast<DWORD_PTR*>(&hEvent) |= 1;
+      DWORD_PTR tmp = reinterpret_cast<DWORD_PTR>(hEvent);
+      hEvent = reinterpret_cast<HANDLE>(tmp | 1);
     }
     else
     {
       DWORD last_error = ::GetLastError();
       ec = boost::system::error_code(last_error,
           boost::asio::error::get_system_category());
@@ -290,13 +291,13 @@ boost::system::error_code win_iocp_handle_service::cancel(
   }
 
   return ec;
 }
 
 size_t win_iocp_handle_service::do_write(
-    win_iocp_handle_service::implementation_type& impl, boost::uint64_t offset,
+    win_iocp_handle_service::implementation_type& impl, uint64_t offset,
     const boost::asio::const_buffer& buffer, boost::system::error_code& ec)
 {
   if (!is_open(impl))
   {
     ec = boost::asio::error::bad_descriptor;
     return 0;
@@ -346,13 +347,13 @@ size_t win_iocp_handle_service::do_write(
 
   ec = boost::system::error_code();
   return bytes_transferred;
 }
 
 void win_iocp_handle_service::start_write_op(
-    win_iocp_handle_service::implementation_type& impl, boost::uint64_t offset,
+    win_iocp_handle_service::implementation_type& impl, uint64_t offset,
     const boost::asio::const_buffer& buffer, operation* op)
 {
   update_cancellation_thread_id(impl);
   iocp_service_.work_started();
 
   if (!is_open(impl))
@@ -384,13 +385,13 @@ void win_iocp_handle_service::start_write_op(
       iocp_service_.on_pending(op);
     }
   }
 }
 
 size_t win_iocp_handle_service::do_read(
-    win_iocp_handle_service::implementation_type& impl, boost::uint64_t offset,
+    win_iocp_handle_service::implementation_type& impl, uint64_t offset,
     const boost::asio::mutable_buffer& buffer, boost::system::error_code& ec)
 {
   if (!is_open(impl))
   {
     ec = boost::asio::error::bad_descriptor;
     return 0;
@@ -446,21 +447,21 @@ size_t win_iocp_handle_service::do_read(
     }
     else
     {
       ec = boost::system::error_code(last_error,
           boost::asio::error::get_system_category());
     }
-    return 0;
+    return (last_error == ERROR_MORE_DATA) ? bytes_transferred : 0;
   }
 
   ec = boost::system::error_code();
   return bytes_transferred;
 }
 
 void win_iocp_handle_service::start_read_op(
-    win_iocp_handle_service::implementation_type& impl, boost::uint64_t offset,
+    win_iocp_handle_service::implementation_type& impl, uint64_t offset,
     const boost::asio::mutable_buffer& buffer, operation* op)
 {
   update_cancellation_thread_id(impl);
   iocp_service_.work_started();
 
   if (!is_open(impl))
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/win_iocp_io_service.hpp b/3rdParty/Boost/src/boost/asio/detail/impl/win_iocp_io_service.hpp
index 871f6fa..201a17e 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/win_iocp_io_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/win_iocp_io_service.hpp
@@ -1,11 +1,11 @@
 //
 // detail/impl/win_iocp_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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_IMPL_WIN_IOCP_IO_SERVICE_HPP
@@ -16,60 +16,61 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
 #if defined(BOOST_ASIO_HAS_IOCP)
 
+#include <boost/asio/detail/addressof.hpp>
 #include <boost/asio/detail/completion_handler.hpp>
 #include <boost/asio/detail/fenced_block.hpp>
 #include <boost/asio/detail/handler_alloc_helpers.hpp>
 #include <boost/asio/detail/handler_invoke_helpers.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 template <typename Handler>
-void win_iocp_io_service::dispatch(Handler handler)
+void win_iocp_io_service::dispatch(Handler& handler)
 {
-  if (call_stack<win_iocp_io_service>::contains(this))
+  if (thread_call_stack::contains(this))
   {
     fenced_block b(fenced_block::full);
     boost_asio_handler_invoke_helpers::invoke(handler, handler);
   }
   else
   {
     // Allocate and construct an operation to wrap the handler.
     typedef completion_handler<Handler> op;
-    typename op::ptr p = { boost::addressof(handler),
+    typename op::ptr p = { boost::asio::detail::addressof(handler),
       boost_asio_handler_alloc_helpers::allocate(
         sizeof(op), handler), 0 };
     p.p = new (p.v) op(handler);
 
     BOOST_ASIO_HANDLER_CREATION((p.p, "io_service", this, "dispatch"));
 
-    post_immediate_completion(p.p);
+    post_immediate_completion(p.p, false);
     p.v = p.p = 0;
   }
 }
 
 template <typename Handler>
-void win_iocp_io_service::post(Handler handler)
+void win_iocp_io_service::post(Handler& handler)
 {
   // Allocate and construct an operation to wrap the handler.
   typedef completion_handler<Handler> op;
-  typename op::ptr p = { boost::addressof(handler),
+  typename op::ptr p = { boost::asio::detail::addressof(handler),
     boost_asio_handler_alloc_helpers::allocate(
       sizeof(op), handler), 0 };
   p.p = new (p.v) op(handler);
 
   BOOST_ASIO_HANDLER_CREATION((p.p, "io_service", this, "post"));
 
-  post_immediate_completion(p.p);
+  post_immediate_completion(p.p, false);
   p.v = p.p = 0;
 }
 
 template <typename Time_Traits>
 void win_iocp_io_service::add_timer_queue(
     timer_queue<Time_Traits>& queue)
@@ -89,13 +90,13 @@ void win_iocp_io_service::schedule_timer(timer_queue<Time_Traits>& queue,
     const typename Time_Traits::time_type& time,
     typename timer_queue<Time_Traits>::per_timer_data& timer, wait_op* op)
 {
   // If the service has been shut down we silently discard the timer.
   if (::InterlockedExchangeAdd(&shutdown_, 0) != 0)
   {
-    post_immediate_completion(op);
+    post_immediate_completion(op, false);
     return;
   }
 
   mutex::scoped_lock lock(dispatch_mutex_);
 
   bool earliest = queue.enqueue_timer(time, timer, op);
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/win_iocp_io_service.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/win_iocp_io_service.ipp
index 72f4af7..fbc1cd0 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/win_iocp_io_service.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/win_iocp_io_service.ipp
@@ -1,11 +1,11 @@
 //
 // detail/impl/win_iocp_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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_IMPL_WIN_IOCP_IO_SERVICE_IPP
@@ -16,17 +16,18 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
 #if defined(BOOST_ASIO_HAS_IOCP)
 
-#include <boost/limits.hpp>
 #include <boost/asio/error.hpp>
 #include <boost/asio/io_service.hpp>
+#include <boost/asio/detail/cstdint.hpp>
 #include <boost/asio/detail/handler_alloc_helpers.hpp>
 #include <boost/asio/detail/handler_invoke_helpers.hpp>
+#include <boost/asio/detail/limits.hpp>
 #include <boost/asio/detail/throw_error.hpp>
 #include <boost/asio/detail/win_iocp_io_service.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
@@ -65,19 +66,22 @@ struct win_iocp_io_service::timer_thread_function
 win_iocp_io_service::win_iocp_io_service(
     boost::asio::io_service& io_service, size_t concurrency_hint)
   : boost::asio::detail::service_base<win_iocp_io_service>(io_service),
     iocp_(),
     outstanding_work_(0),
     stopped_(0),
+    stop_event_posted_(0),
     shutdown_(0),
+    gqcs_timeout_(get_gqcs_timeout()),
     dispatch_required_(0)
 {
   BOOST_ASIO_HANDLER_TRACKING_INIT;
 
   iocp_.handle = ::CreateIoCompletionPort(INVALID_HANDLE_VALUE, 0, 0,
-      static_cast<DWORD>((std::min<size_t>)(concurrency_hint, DWORD(~0))));
+      static_cast<DWORD>(concurrency_hint < DWORD(~0)
+        ? concurrency_hint : DWORD(~0)));
   if (!iocp_.handle)
   {
     DWORD last_error = ::GetLastError();
     boost::system::error_code ec(last_error,
         boost::asio::error::get_system_category());
     boost::asio::detail::throw_error(ec, "iocp");
@@ -112,13 +116,13 @@ void win_iocp_io_service::shutdown_service()
     else
     {
       DWORD bytes_transferred = 0;
       dword_ptr_t completion_key = 0;
       LPOVERLAPPED overlapped = 0;
       ::GetQueuedCompletionStatus(iocp_.handle, &bytes_transferred,
-          &completion_key, &overlapped, gqcs_timeout);
+          &completion_key, &overlapped, gqcs_timeout_);
       if (overlapped)
       {
         ::InterlockedDecrement(&outstanding_work_);
         static_cast<win_iocp_operation*>(overlapped)->destroy();
       }
     }
@@ -145,94 +149,100 @@ boost::system::error_code win_iocp_io_service::register_handle(
 }
 
 size_t win_iocp_io_service::run(boost::system::error_code& ec)
 {
   if (::InterlockedExchangeAdd(&outstanding_work_, 0) == 0)
   {
-    InterlockedExchange(&stopped_, 1);
+    stop();
     ec = boost::system::error_code();
     return 0;
   }
 
-  call_stack<win_iocp_io_service>::context ctx(this);
+  win_iocp_thread_info this_thread;
+  thread_call_stack::context ctx(this, this_thread);
 
   size_t n = 0;
   while (do_one(true, ec))
     if (n != (std::numeric_limits<size_t>::max)())
       ++n;
   return n;
 }
 
 size_t win_iocp_io_service::run_one(boost::system::error_code& ec)
 {
   if (::InterlockedExchangeAdd(&outstanding_work_, 0) == 0)
   {
-    InterlockedExchange(&stopped_, 1);
+    stop();
     ec = boost::system::error_code();
     return 0;
   }
 
-  call_stack<win_iocp_io_service>::context ctx(this);
+  win_iocp_thread_info this_thread;
+  thread_call_stack::context ctx(this, this_thread);
 
   return do_one(true, ec);
 }
 
 size_t win_iocp_io_service::poll(boost::system::error_code& ec)
 {
   if (::InterlockedExchangeAdd(&outstanding_work_, 0) == 0)
   {
-    InterlockedExchange(&stopped_, 1);
+    stop();
     ec = boost::system::error_code();
     return 0;
   }
 
-  call_stack<win_iocp_io_service>::context ctx(this);
+  win_iocp_thread_info this_thread;
+  thread_call_stack::context ctx(this, this_thread);
 
   size_t n = 0;
   while (do_one(false, ec))
     if (n != (std::numeric_limits<size_t>::max)())
       ++n;
   return n;
 }
 
 size_t win_iocp_io_service::poll_one(boost::system::error_code& ec)
 {
   if (::InterlockedExchangeAdd(&outstanding_work_, 0) == 0)
   {
-    InterlockedExchange(&stopped_, 1);
+    stop();
     ec = boost::system::error_code();
     return 0;
   }
 
-  call_stack<win_iocp_io_service>::context ctx(this);
+  win_iocp_thread_info this_thread;
+  thread_call_stack::context ctx(this, this_thread);
 
   return do_one(false, ec);
 }
 
 void win_iocp_io_service::stop()
 {
   if (::InterlockedExchange(&stopped_, 1) == 0)
   {
-    if (!::PostQueuedCompletionStatus(iocp_.handle, 0, 0, 0))
+    if (::InterlockedExchange(&stop_event_posted_, 1) == 0)
     {
-      DWORD last_error = ::GetLastError();
-      boost::system::error_code ec(last_error,
-          boost::asio::error::get_system_category());
-      boost::asio::detail::throw_error(ec, "pqcs");
+      if (!::PostQueuedCompletionStatus(iocp_.handle, 0, 0, 0))
+      {
+        DWORD last_error = ::GetLastError();
+        boost::system::error_code ec(last_error,
+            boost::asio::error::get_system_category());
+        boost::asio::detail::throw_error(ec, "pqcs");
+      }
     }
   }
 }
 
 void win_iocp_io_service::post_deferred_completion(win_iocp_operation* op)
 {
   // Flag the operation as ready.
   op->ready_ = 1;
 
   // Enqueue the operation on the I/O completion port.
-  if (!::PostQueuedCompletionStatus(iocp_.handle,
-        0, overlapped_contains_result, op))
+  if (!::PostQueuedCompletionStatus(iocp_.handle, 0, 0, op))
   {
     // Out of resources. Put on completed queue instead.
     mutex::scoped_lock lock(dispatch_mutex_);
     completed_ops_.push(op);
     ::InterlockedExchange(&dispatch_required_, 1);
   }
@@ -246,14 +256,13 @@ void win_iocp_io_service::post_deferred_completions(
     ops.pop();
 
     // Flag the operation as ready.
     op->ready_ = 1;
 
     // Enqueue the operation on the I/O completion port.
-    if (!::PostQueuedCompletionStatus(iocp_.handle,
-          0, overlapped_contains_result, op))
+    if (!::PostQueuedCompletionStatus(iocp_.handle, 0, 0, op))
     {
       // Out of resources. Put on completed queue instead.
       mutex::scoped_lock lock(dispatch_mutex_);
       completed_ops_.push(op);
       completed_ops_.push(ops);
       ::InterlockedExchange(&dispatch_required_, 1);
@@ -353,13 +362,13 @@ size_t win_iocp_io_service::do_one(bool block, boost::system::error_code& ec)
     // Get the next operation from the queue.
     DWORD bytes_transferred = 0;
     dword_ptr_t completion_key = 0;
     LPOVERLAPPED overlapped = 0;
     ::SetLastError(0);
     BOOL ok = ::GetQueuedCompletionStatus(iocp_.handle, &bytes_transferred,
-        &completion_key, &overlapped, block ? gqcs_timeout : 0);
+        &completion_key, &overlapped, block ? gqcs_timeout_ : 0);
     DWORD last_error = ::GetLastError();
 
     if (overlapped)
     {
       win_iocp_operation* op = static_cast<win_iocp_operation*>(overlapped);
       boost::system::error_code result_ec(last_error,
@@ -418,32 +427,54 @@ size_t win_iocp_io_service::do_one(bool block, boost::system::error_code& ec)
     {
       // We have been woken up to try to acquire responsibility for dispatching
       // timers and completed operations.
     }
     else
     {
+      // Indicate that there is no longer an in-flight stop event.
+      ::InterlockedExchange(&stop_event_posted_, 0);
+
       // The stopped_ flag is always checked to ensure that any leftover
-      // interrupts from a previous run invocation are ignored.
+      // stop events from a previous run invocation are ignored.
       if (::InterlockedExchangeAdd(&stopped_, 0) != 0)
       {
         // Wake up next thread that is blocked on GetQueuedCompletionStatus.
-        if (!::PostQueuedCompletionStatus(iocp_.handle, 0, 0, 0))
+        if (::InterlockedExchange(&stop_event_posted_, 1) == 0)
         {
-          last_error = ::GetLastError();
-          ec = boost::system::error_code(last_error,
-              boost::asio::error::get_system_category());
-          return 0;
+          if (!::PostQueuedCompletionStatus(iocp_.handle, 0, 0, 0))
+          {
+            last_error = ::GetLastError();
+            ec = boost::system::error_code(last_error,
+                boost::asio::error::get_system_category());
+            return 0;
+          }
         }
 
         ec = boost::system::error_code();
         return 0;
       }
     }
   }
 }
 
+DWORD win_iocp_io_service::get_gqcs_timeout()
+{
+  OSVERSIONINFOEX osvi;
+  ZeroMemory(&osvi, sizeof(osvi));
+  osvi.dwOSVersionInfoSize = sizeof(osvi);
+  osvi.dwMajorVersion = 6ul;
+
+  const uint64_t condition_mask = ::VerSetConditionMask(
+      0, VER_MAJORVERSION, VER_GREATER_EQUAL);
+
+  if (!!::VerifyVersionInfo(&osvi, VER_MAJORVERSION, condition_mask))
+    return INFINITE;
+
+  return default_gqcs_timeout;
+}
+
 void win_iocp_io_service::do_add_timer_queue(timer_queue_base& queue)
 {
   mutex::scoped_lock lock(dispatch_mutex_);
 
   timer_queues_.insert(&queue);
 
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/win_iocp_serial_port_service.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/win_iocp_serial_port_service.ipp
index e98ad87..e3081af 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/win_iocp_serial_port_service.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/win_iocp_serial_port_service.ipp
@@ -1,11 +1,11 @@
 //
 // detail/impl/win_iocp_serial_port_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)
 // Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.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)
 //
 
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/win_iocp_socket_service_base.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/win_iocp_socket_service_base.ipp
index 0466e33..40231b9 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/win_iocp_socket_service_base.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/win_iocp_socket_service_base.ipp
@@ -1,11 +1,11 @@
 //
 // detail/impl/win_iocp_socket_service_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)
 //
 // 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_DETAIL_IMPL_WIN_IOCP_SOCKET_SERVICE_BASE_IPP
@@ -29,12 +29,13 @@ namespace detail {
 
 win_iocp_socket_service_base::win_iocp_socket_service_base(
     boost::asio::io_service& io_service)
   : io_service_(io_service),
     iocp_service_(use_service<win_iocp_io_service>(io_service)),
     reactor_(0),
+    connect_ex_(0),
     mutex_(),
     impl_list_(0)
 {
 }
 
 void win_iocp_socket_service_base::shutdown_service()
@@ -531,25 +532,68 @@ void win_iocp_socket_service_base::start_reactor_op(
 {
   reactor& r = get_reactor();
   update_cancellation_thread_id(impl);
 
   if (is_open(impl))
   {
-    r.start_op(op_type, impl.socket_, impl.reactor_data_, op, false);
+    r.start_op(op_type, impl.socket_, impl.reactor_data_, op, false, false);
     return;
   }
   else
     op->ec_ = boost::asio::error::bad_descriptor;
 
-  iocp_service_.post_immediate_completion(op);
+  iocp_service_.post_immediate_completion(op, false);
 }
 
 void win_iocp_socket_service_base::start_connect_op(
     win_iocp_socket_service_base::base_implementation_type& impl,
-    reactor_op* op, const socket_addr_type* addr, std::size_t addrlen)
+    int family, int type, const socket_addr_type* addr,
+    std::size_t addrlen, win_iocp_socket_connect_op_base* op)
 {
+  // If ConnectEx is available, use that.
+  if (family == BOOST_ASIO_OS_DEF(AF_INET)
+      || family == BOOST_ASIO_OS_DEF(AF_INET6))
+  {
+    if (connect_ex_fn connect_ex = get_connect_ex(impl, type))
+    {
+      union address_union
+      {
+        socket_addr_type base;
+        sockaddr_in4_type v4;
+        sockaddr_in6_type v6;
+      } a;
+
+      using namespace std; // For memset.
+      memset(&a, 0, sizeof(a));
+      a.base.sa_family = family;
+
+      socket_ops::bind(impl.socket_, &a.base,
+          family == BOOST_ASIO_OS_DEF(AF_INET)
+          ? sizeof(a.v4) : sizeof(a.v6), op->ec_);
+      if (op->ec_ && op->ec_ != boost::asio::error::invalid_argument)
+      {
+        iocp_service_.post_immediate_completion(op, false);
+        return;
+      }
+
+      op->connect_ex_ = true;
+      update_cancellation_thread_id(impl);
+      iocp_service_.work_started();
+
+      BOOL result = connect_ex(impl.socket_,
+          addr, static_cast<int>(addrlen), 0, 0, 0, op);
+      DWORD last_error = ::WSAGetLastError();
+      if (!result && last_error != WSA_IO_PENDING)
+        iocp_service_.on_completion(op, last_error);
+      else
+        iocp_service_.on_pending(op);
+      return;
+    }
+  }
+
+  // Otherwise, fall back to a reactor-based implementation.
   reactor& r = get_reactor();
   update_cancellation_thread_id(impl);
 
   if ((impl.state_ & socket_ops::non_blocking) != 0
       || socket_ops::set_internal_non_blocking(
         impl.socket_, impl.state_, true, op->ec_))
@@ -558,19 +602,19 @@ void win_iocp_socket_service_base::start_connect_op(
     {
       if (op->ec_ == boost::asio::error::in_progress
           || op->ec_ == boost::asio::error::would_block)
       {
         op->ec_ = boost::system::error_code();
         r.start_op(reactor::connect_op, impl.socket_,
-            impl.reactor_data_, op, false);
+            impl.reactor_data_, op, false, false);
         return;
       }
     }
   }
 
-  r.post_immediate_completion(op);
+  r.post_immediate_completion(op, false);
 }
 
 void win_iocp_socket_service_base::close_for_destruction(
     win_iocp_socket_service_base::base_implementation_type& impl)
 {
   if (is_open(impl))
@@ -620,12 +664,41 @@ reactor& win_iocp_socket_service_base::get_reactor()
     r = &(use_service<reactor>(io_service_));
     interlocked_exchange_pointer(reinterpret_cast<void**>(&reactor_), r);
   }
   return *r;
 }
 
+win_iocp_socket_service_base::connect_ex_fn
+win_iocp_socket_service_base::get_connect_ex(
+    win_iocp_socket_service_base::base_implementation_type& impl, int type)
+{
+  if (type != BOOST_ASIO_OS_DEF(SOCK_STREAM)
+      && type != BOOST_ASIO_OS_DEF(SOCK_SEQPACKET))
+    return 0;
+
+  void* ptr = interlocked_compare_exchange_pointer(&connect_ex_, 0, 0);
+  if (!ptr)
+  {
+    GUID guid = { 0x25a207b9, 0xddf3, 0x4660,
+      { 0x8e, 0xe9, 0x76, 0xe5, 0x8c, 0x74, 0x06, 0x3e } };
+
+    DWORD bytes = 0;
+    if (::WSAIoctl(impl.socket_, SIO_GET_EXTENSION_FUNCTION_POINTER,
+          &guid, sizeof(guid), &ptr, sizeof(ptr), &bytes, 0, 0) != 0)
+    {
+      // Set connect_ex_ to a special value to indicate that ConnectEx is
+      // unavailable. That way we won't bother trying to look it up again.
+      ptr = this;
+    }
+
+    interlocked_exchange_pointer(&connect_ex_, ptr);
+  }
+
+  return reinterpret_cast<connect_ex_fn>(ptr == this ? 0 : ptr);
+}
+
 void* win_iocp_socket_service_base::interlocked_compare_exchange_pointer(
     void** dest, void* exch, void* cmp)
 {
 #if defined(_M_IX86)
   return reinterpret_cast<void*>(InterlockedCompareExchange(
         reinterpret_cast<PLONG>(dest), reinterpret_cast<LONG>(exch),
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/win_mutex.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/win_mutex.ipp
index 05a7492..f86012b 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/win_mutex.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/win_mutex.ipp
@@ -1,11 +1,11 @@
 //
 // detail/impl/win_mutex.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_IMPL_WIN_MUTEX_IPP
@@ -14,13 +14,13 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
-#if defined(BOOST_WINDOWS)
+#if defined(BOOST_ASIO_WINDOWS)
 
 #include <boost/asio/detail/throw_error.hpp>
 #include <boost/asio/detail/win_mutex.hpp>
 #include <boost/asio/error.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
@@ -72,9 +72,9 @@ int win_mutex::do_init()
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
-#endif // defined(BOOST_WINDOWS)
+#endif // defined(BOOST_ASIO_WINDOWS)
 
 #endif // BOOST_ASIO_DETAIL_IMPL_WIN_MUTEX_IPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/win_object_handle_service.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/win_object_handle_service.ipp
index d91ccac..081d5eb 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/win_object_handle_service.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/win_object_handle_service.ipp
@@ -1,11 +1,11 @@
 //
 // detail/impl/win_object_handle_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)
 // Copyright (c) 2011 Boris Schaeling (boris@highscore.de)
 //
 // 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)
 //
 
@@ -418,13 +418,13 @@ void win_object_handle_service::wait_callback(PVOID param, BOOLEAN)
             param, INFINITE, WT_EXECUTEONLYONCE))
       {
         DWORD last_error = ::GetLastError();
         boost::system::error_code ec(last_error,
             boost::asio::error::get_system_category());
 
-        while (wait_op* op = impl->op_queue_.front())
+        while ((op = impl->op_queue_.front()) != 0)
         {
           op->ec_ = ec;
           impl->op_queue_.pop();
           completed_ops.push(op);
         }
       }
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/win_static_mutex.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/win_static_mutex.ipp
index 3ec104d..84bd454 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/win_static_mutex.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/win_static_mutex.ipp
@@ -1,11 +1,11 @@
 //
 // detail/impl/win_static_mutex.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_IMPL_WIN_STATIC_MUTEX_IPP
@@ -14,13 +14,13 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
-#if defined(BOOST_WINDOWS)
+#if defined(BOOST_ASIO_WINDOWS)
 
 #include <cstdio>
 #include <boost/asio/detail/throw_error.hpp>
 #include <boost/asio/detail/win_static_mutex.hpp>
 #include <boost/asio/error.hpp>
 
@@ -39,18 +39,18 @@ void win_static_mutex::init()
 }
 
 int win_static_mutex::do_init()
 {
   using namespace std; // For sprintf.
   wchar_t mutex_name[128];
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) && !defined(UNDER_CE)
-  swprintf_s(mutex_name, 128,
-#else // BOOST_WORKAROUND(BOOST_MSVC, >= 1400) && !defined(UNDER_CE)
-  swprintf(mutex_name,
-#endif // BOOST_WORKAROUND(BOOST_MSVC, >= 1400) && !defined(UNDER_CE)
-      L"asio-58CCDC44-6264-4842-90C2-F3C545CB8AA7-%u-%p",
+#if defined(BOOST_ASIO_HAS_SECURE_RTL)
+  swprintf_s(
+#else // defined(BOOST_ASIO_HAS_SECURE_RTL)
+  _snwprintf(
+#endif // defined(BOOST_ASIO_HAS_SECURE_RTL)
+      mutex_name, 128, L"asio-58CCDC44-6264-4842-90C2-F3C545CB8AA7-%u-%p",
       static_cast<unsigned int>(::GetCurrentProcessId()), this);
 
   HANDLE mutex = ::CreateMutexW(0, TRUE, mutex_name);
   DWORD last_error = ::GetLastError();
   if (mutex == 0)
     return ::GetLastError();
@@ -112,9 +112,9 @@ int win_static_mutex::do_init()
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
-#endif // defined(BOOST_WINDOWS)
+#endif // defined(BOOST_ASIO_WINDOWS)
 
 #endif // BOOST_ASIO_DETAIL_IMPL_WIN_STATIC_MUTEX_IPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/win_thread.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/win_thread.ipp
index 744990d..4bf09c5 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/win_thread.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/win_thread.ipp
@@ -1,11 +1,11 @@
 //
 // detail/impl/win_thread.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_IMPL_WIN_THREAD_IPP
@@ -14,13 +14,13 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
-#if defined(BOOST_WINDOWS) && !defined(UNDER_CE)
+#if defined(BOOST_ASIO_WINDOWS) && !defined(UNDER_CE)
 
 #include <process.h>
 #include <boost/asio/detail/throw_error.hpp>
 #include <boost/asio/detail/win_thread.hpp>
 #include <boost/asio/error.hpp>
 
@@ -133,9 +133,9 @@ void __stdcall apc_function(ULONG_PTR) {}
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
-#endif // defined(BOOST_WINDOWS) && !defined(UNDER_CE)
+#endif // defined(BOOST_ASIO_WINDOWS) && !defined(UNDER_CE)
 
 #endif // BOOST_ASIO_DETAIL_IMPL_WIN_THREAD_IPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/win_tss_ptr.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/win_tss_ptr.ipp
index 9da761c..abaad27 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/win_tss_ptr.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/win_tss_ptr.ipp
@@ -1,11 +1,11 @@
 //
 // detail/impl/win_tss_ptr.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_IMPL_WIN_TSS_PTR_IPP
@@ -14,13 +14,13 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
-#if defined(BOOST_WINDOWS)
+#if defined(BOOST_ASIO_WINDOWS)
 
 #include <boost/asio/detail/throw_error.hpp>
 #include <boost/asio/detail/win_tss_ptr.hpp>
 #include <boost/asio/error.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
@@ -51,9 +51,9 @@ DWORD win_tss_ptr_create()
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
-#endif // defined(BOOST_WINDOWS)
+#endif // defined(BOOST_ASIO_WINDOWS)
 
 #endif // BOOST_ASIO_DETAIL_IMPL_WIN_TSS_PTR_IPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/winrt_ssocket_service_base.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/winrt_ssocket_service_base.ipp
new file mode 100644
index 0000000..fdd0465
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/winrt_ssocket_service_base.ipp
@@ -0,0 +1,614 @@
+//
+// detail/impl/winrt_ssocket_service_base.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_DETAIL_IMPL_WINRT_SSOCKET_SERVICE_BASE_IPP
+#define BOOST_ASIO_DETAIL_IMPL_WINRT_SSOCKET_SERVICE_BASE_IPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_WINDOWS_RUNTIME)
+
+#include <cstring>
+#include <boost/asio/detail/winrt_ssocket_service_base.hpp>
+#include <boost/asio/detail/winrt_async_op.hpp>
+#include <boost/asio/detail/winrt_utils.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+winrt_ssocket_service_base::winrt_ssocket_service_base(
+    boost::asio::io_service& io_service)
+  : io_service_(use_service<io_service_impl>(io_service)),
+    async_manager_(use_service<winrt_async_manager>(io_service)),
+    mutex_(),
+    impl_list_(0)
+{
+}
+
+void winrt_ssocket_service_base::shutdown_service()
+{
+  // Close all implementations, causing all operations to complete.
+  boost::asio::detail::mutex::scoped_lock lock(mutex_);
+  base_implementation_type* impl = impl_list_;
+  while (impl)
+  {
+    boost::system::error_code ignored_ec;
+    close(*impl, ignored_ec);
+    impl = impl->next_;
+  }
+}
+
+void winrt_ssocket_service_base::construct(
+    winrt_ssocket_service_base::base_implementation_type& impl)
+{
+  // Insert implementation into linked list of all implementations.
+  boost::asio::detail::mutex::scoped_lock lock(mutex_);
+  impl.next_ = impl_list_;
+  impl.prev_ = 0;
+  if (impl_list_)
+    impl_list_->prev_ = &impl;
+  impl_list_ = &impl;
+}
+
+void winrt_ssocket_service_base::base_move_construct(
+    winrt_ssocket_service_base::base_implementation_type& impl,
+    winrt_ssocket_service_base::base_implementation_type& other_impl)
+{
+  impl.socket_ = other_impl.socket_;
+  other_impl.socket_ = nullptr;
+
+  // Insert implementation into linked list of all implementations.
+  boost::asio::detail::mutex::scoped_lock lock(mutex_);
+  impl.next_ = impl_list_;
+  impl.prev_ = 0;
+  if (impl_list_)
+    impl_list_->prev_ = &impl;
+  impl_list_ = &impl;
+}
+
+void winrt_ssocket_service_base::base_move_assign(
+    winrt_ssocket_service_base::base_implementation_type& impl,
+    winrt_ssocket_service_base& other_service,
+    winrt_ssocket_service_base::base_implementation_type& other_impl)
+{
+  boost::system::error_code ignored_ec;
+  close(impl, ignored_ec);
+
+  if (this != &other_service)
+  {
+    // Remove implementation from linked list of all implementations.
+    boost::asio::detail::mutex::scoped_lock lock(mutex_);
+    if (impl_list_ == &impl)
+      impl_list_ = impl.next_;
+    if (impl.prev_)
+      impl.prev_->next_ = impl.next_;
+    if (impl.next_)
+      impl.next_->prev_= impl.prev_;
+    impl.next_ = 0;
+    impl.prev_ = 0;
+  }
+
+  impl.socket_ = other_impl.socket_;
+  other_impl.socket_ = nullptr;
+
+  if (this != &other_service)
+  {
+    // Insert implementation into linked list of all implementations.
+    boost::asio::detail::mutex::scoped_lock lock(other_service.mutex_);
+    impl.next_ = other_service.impl_list_;
+    impl.prev_ = 0;
+    if (other_service.impl_list_)
+      other_service.impl_list_->prev_ = &impl;
+    other_service.impl_list_ = &impl;
+  }
+}
+
+void winrt_ssocket_service_base::destroy(
+    winrt_ssocket_service_base::base_implementation_type& impl)
+{
+  boost::system::error_code ignored_ec;
+  close(impl, ignored_ec);
+
+  // Remove implementation from linked list of all implementations.
+  boost::asio::detail::mutex::scoped_lock lock(mutex_);
+  if (impl_list_ == &impl)
+    impl_list_ = impl.next_;
+  if (impl.prev_)
+    impl.prev_->next_ = impl.next_;
+  if (impl.next_)
+    impl.next_->prev_= impl.prev_;
+  impl.next_ = 0;
+  impl.prev_ = 0;
+}
+
+boost::system::error_code winrt_ssocket_service_base::close(
+    winrt_ssocket_service_base::base_implementation_type& impl,
+    boost::system::error_code& ec)
+{
+  if (impl.socket_)
+  {
+    delete impl.socket_;
+    impl.socket_ = nullptr;
+  }
+
+  ec = boost::system::error_code();
+  return ec;
+}
+
+std::size_t winrt_ssocket_service_base::do_get_endpoint(
+    const base_implementation_type& impl, bool local,
+    void* addr, std::size_t addr_len, boost::system::error_code& ec) const
+{
+  if (!is_open(impl))
+  {
+    ec = boost::asio::error::bad_descriptor;
+    return addr_len;
+  }
+
+  try
+  {
+    std::string addr_string = winrt_utils::string(local
+        ? impl.socket_->Information->LocalAddress->CanonicalName
+        : impl.socket_->Information->RemoteAddress->CanonicalName);
+    unsigned short port = winrt_utils::integer(local
+        ? impl.socket_->Information->LocalPort
+        : impl.socket_->Information->RemotePort);
+    unsigned long scope = 0;
+
+    switch (reinterpret_cast<const socket_addr_type*>(addr)->sa_family)
+    {
+    case BOOST_ASIO_OS_DEF(AF_INET):
+      if (addr_len < sizeof(sockaddr_in4_type))
+      {
+        ec = boost::asio::error::invalid_argument;
+        return addr_len;
+      }
+      else
+      {
+        socket_ops::inet_pton(BOOST_ASIO_OS_DEF(AF_INET), addr_string.c_str(),
+            &reinterpret_cast<sockaddr_in4_type*>(addr)->sin_addr, &scope, ec);
+        reinterpret_cast<sockaddr_in4_type*>(addr)->sin_port
+          = socket_ops::host_to_network_short(port);
+        ec = boost::system::error_code();
+        return sizeof(sockaddr_in4_type);
+      }
+    case BOOST_ASIO_OS_DEF(AF_INET6):
+      if (addr_len < sizeof(sockaddr_in6_type))
+      {
+        ec = boost::asio::error::invalid_argument;
+        return addr_len;
+      }
+      else
+      {
+        socket_ops::inet_pton(BOOST_ASIO_OS_DEF(AF_INET6), addr_string.c_str(),
+            &reinterpret_cast<sockaddr_in6_type*>(addr)->sin6_addr, &scope, ec);
+        reinterpret_cast<sockaddr_in6_type*>(addr)->sin6_port
+          = socket_ops::host_to_network_short(port);
+        ec = boost::system::error_code();
+        return sizeof(sockaddr_in6_type);
+      }
+    default:
+      ec = boost::asio::error::address_family_not_supported;
+      return addr_len;
+    }
+  }
+  catch (Platform::Exception^ e)
+  {
+    ec = boost::system::error_code(e->HResult,
+        boost::system::system_category());
+    return addr_len;
+  }
+}
+
+boost::system::error_code winrt_ssocket_service_base::do_set_option(
+    winrt_ssocket_service_base::base_implementation_type& impl,
+    int level, int optname, const void* optval,
+    std::size_t optlen, boost::system::error_code& ec)
+{
+  if (!is_open(impl))
+  {
+    ec = boost::asio::error::bad_descriptor;
+    return ec;
+  }
+
+  try
+  {
+    if (level == BOOST_ASIO_OS_DEF(SOL_SOCKET)
+        && optname == BOOST_ASIO_OS_DEF(SO_KEEPALIVE))
+    {
+      if (optlen == sizeof(int))
+      {
+        int value = 0;
+        std::memcpy(&value, optval, optlen);
+        impl.socket_->Control->KeepAlive = !!value;
+        ec = boost::system::error_code();
+      }
+      else
+      {
+        ec = boost::asio::error::invalid_argument;
+      }
+    }
+    else if (level == BOOST_ASIO_OS_DEF(IPPROTO_TCP)
+        && optname == BOOST_ASIO_OS_DEF(TCP_NODELAY))
+    {
+      if (optlen == sizeof(int))
+      {
+        int value = 0;
+        std::memcpy(&value, optval, optlen);
+        impl.socket_->Control->NoDelay = !!value;
+        ec = boost::system::error_code();
+      }
+      else
+      {
+        ec = boost::asio::error::invalid_argument;
+      }
+    }
+    else
+    {
+      ec = boost::asio::error::invalid_argument;
+    }
+  }
+  catch (Platform::Exception^ e)
+  {
+    ec = boost::system::error_code(e->HResult,
+        boost::system::system_category());
+  }
+
+  return ec;
+}
+
+void winrt_ssocket_service_base::do_get_option(
+    const winrt_ssocket_service_base::base_implementation_type& impl,
+    int level, int optname, void* optval,
+    std::size_t* optlen, boost::system::error_code& ec) const
+{
+  if (!is_open(impl))
+  {
+    ec = boost::asio::error::bad_descriptor;
+    return;
+  }
+
+  try
+  {
+    if (level == BOOST_ASIO_OS_DEF(SOL_SOCKET)
+        && optname == BOOST_ASIO_OS_DEF(SO_KEEPALIVE))
+    {
+      if (*optlen >= sizeof(int))
+      {
+        int value = impl.socket_->Control->KeepAlive ? 1 : 0;
+        std::memcpy(optval, &value, sizeof(int));
+        *optlen = sizeof(int);
+        ec = boost::system::error_code();
+      }
+      else
+      {
+        ec = boost::asio::error::invalid_argument;
+      }
+    }
+    else if (level == BOOST_ASIO_OS_DEF(IPPROTO_TCP)
+        && optname == BOOST_ASIO_OS_DEF(TCP_NODELAY))
+    {
+      if (*optlen >= sizeof(int))
+      {
+        int value = impl.socket_->Control->NoDelay ? 1 : 0;
+        std::memcpy(optval, &value, sizeof(int));
+        *optlen = sizeof(int);
+        ec = boost::system::error_code();
+      }
+      else
+      {
+        ec = boost::asio::error::invalid_argument;
+      }
+    }
+    else
+    {
+      ec = boost::asio::error::invalid_argument;
+    }
+  }
+  catch (Platform::Exception^ e)
+  {
+    ec = boost::system::error_code(e->HResult,
+        boost::system::system_category());
+  }
+}
+
+boost::system::error_code winrt_ssocket_service_base::do_connect(
+    winrt_ssocket_service_base::base_implementation_type& impl,
+    const void* addr, boost::system::error_code& ec)
+{
+  if (!is_open(impl))
+  {
+    ec = boost::asio::error::bad_descriptor;
+    return ec;
+  }
+
+  char addr_string[max_addr_v6_str_len];
+  unsigned short port;
+  switch (reinterpret_cast<const socket_addr_type*>(addr)->sa_family)
+  {
+  case BOOST_ASIO_OS_DEF(AF_INET):
+    socket_ops::inet_ntop(BOOST_ASIO_OS_DEF(AF_INET),
+        &reinterpret_cast<const sockaddr_in4_type*>(addr)->sin_addr,
+        addr_string, sizeof(addr_string), 0, ec);
+    port = socket_ops::network_to_host_short(
+        reinterpret_cast<const sockaddr_in4_type*>(addr)->sin_port);
+    break;
+  case BOOST_ASIO_OS_DEF(AF_INET6):
+    socket_ops::inet_ntop(BOOST_ASIO_OS_DEF(AF_INET6),
+        &reinterpret_cast<const sockaddr_in6_type*>(addr)->sin6_addr,
+        addr_string, sizeof(addr_string), 0, ec);
+    port = socket_ops::network_to_host_short(
+        reinterpret_cast<const sockaddr_in6_type*>(addr)->sin6_port);
+    break;
+  default:
+    ec = boost::asio::error::address_family_not_supported;
+    return ec;
+  }
+
+  if (!ec) try
+  {
+    async_manager_.sync(impl.socket_->ConnectAsync(
+          ref new Windows::Networking::HostName(
+            winrt_utils::string(addr_string)),
+          winrt_utils::string(port)), ec);
+  }
+  catch (Platform::Exception^ e)
+  {
+    ec = boost::system::error_code(e->HResult,
+        boost::system::system_category());
+  }
+
+  return ec;
+}
+
+void winrt_ssocket_service_base::start_connect_op(
+    winrt_ssocket_service_base::base_implementation_type& impl,
+    const void* addr, winrt_async_op<void>* op, bool is_continuation)
+{
+  if (!is_open(impl))
+  {
+    op->ec_ = boost::asio::error::bad_descriptor;
+    io_service_.post_immediate_completion(op, is_continuation);
+    return;
+  }
+
+  char addr_string[max_addr_v6_str_len];
+  unsigned short port = 0;
+  switch (reinterpret_cast<const socket_addr_type*>(addr)->sa_family)
+  {
+  case BOOST_ASIO_OS_DEF(AF_INET):
+    socket_ops::inet_ntop(BOOST_ASIO_OS_DEF(AF_INET),
+        &reinterpret_cast<const sockaddr_in4_type*>(addr)->sin_addr,
+        addr_string, sizeof(addr_string), 0, op->ec_);
+    port = socket_ops::network_to_host_short(
+        reinterpret_cast<const sockaddr_in4_type*>(addr)->sin_port);
+    break;
+  case BOOST_ASIO_OS_DEF(AF_INET6):
+    socket_ops::inet_ntop(BOOST_ASIO_OS_DEF(AF_INET6),
+        &reinterpret_cast<const sockaddr_in6_type*>(addr)->sin6_addr,
+        addr_string, sizeof(addr_string), 0, op->ec_);
+    port = socket_ops::network_to_host_short(
+        reinterpret_cast<const sockaddr_in6_type*>(addr)->sin6_port);
+    break;
+  default:
+    op->ec_ = boost::asio::error::address_family_not_supported;
+    break;
+  }
+
+  if (op->ec_)
+  {
+    io_service_.post_immediate_completion(op, is_continuation);
+    return;
+  }
+
+  try
+  {
+    async_manager_.async(impl.socket_->ConnectAsync(
+          ref new Windows::Networking::HostName(
+            winrt_utils::string(addr_string)),
+          winrt_utils::string(port)), op);
+  }
+  catch (Platform::Exception^ e)
+  {
+    op->ec_ = boost::system::error_code(
+        e->HResult, boost::system::system_category());
+    io_service_.post_immediate_completion(op, is_continuation);
+  }
+}
+
+std::size_t winrt_ssocket_service_base::do_send(
+    winrt_ssocket_service_base::base_implementation_type& impl,
+    const boost::asio::const_buffer& data,
+    socket_base::message_flags flags, boost::system::error_code& ec)
+{
+  if (flags)
+  {
+    ec = boost::asio::error::operation_not_supported;
+    return 0;
+  }
+
+  if (!is_open(impl))
+  {
+    ec = boost::asio::error::bad_descriptor;
+    return 0;
+  }
+
+  try
+  {
+    buffer_sequence_adapter<boost::asio::const_buffer,
+      boost::asio::const_buffers_1> bufs(boost::asio::buffer(data));
+
+    if (bufs.all_empty())
+    {
+      ec = boost::system::error_code();
+      return 0;
+    }
+
+    return async_manager_.sync(
+        impl.socket_->OutputStream->WriteAsync(bufs.buffers()[0]), ec);
+  }
+  catch (Platform::Exception^ e)
+  {
+    ec = boost::system::error_code(e->HResult,
+        boost::system::system_category());
+    return 0;
+  }
+}
+
+void winrt_ssocket_service_base::start_send_op(
+      winrt_ssocket_service_base::base_implementation_type& impl,
+      const boost::asio::const_buffer& data, socket_base::message_flags flags,
+      winrt_async_op<unsigned int>* op, bool is_continuation)
+{
+  if (flags)
+  {
+    op->ec_ = boost::asio::error::operation_not_supported;
+    io_service_.post_immediate_completion(op, is_continuation);
+    return;
+  }
+
+  if (!is_open(impl))
+  {
+    op->ec_ = boost::asio::error::bad_descriptor;
+    io_service_.post_immediate_completion(op, is_continuation);
+    return;
+  }
+
+  try
+  {
+    buffer_sequence_adapter<boost::asio::const_buffer,
+        boost::asio::const_buffers_1> bufs(boost::asio::buffer(data));
+
+    if (bufs.all_empty())
+    {
+      io_service_.post_immediate_completion(op, is_continuation);
+      return;
+    }
+
+    async_manager_.async(
+        impl.socket_->OutputStream->WriteAsync(bufs.buffers()[0]), op);
+  }
+  catch (Platform::Exception^ e)
+  {
+    op->ec_ = boost::system::error_code(e->HResult,
+        boost::system::system_category());
+    io_service_.post_immediate_completion(op, is_continuation);
+  }
+}
+
+std::size_t winrt_ssocket_service_base::do_receive(
+    winrt_ssocket_service_base::base_implementation_type& impl,
+    const boost::asio::mutable_buffer& data,
+    socket_base::message_flags flags, boost::system::error_code& ec)
+{
+  if (flags)
+  {
+    ec = boost::asio::error::operation_not_supported;
+    return 0;
+  }
+
+  if (!is_open(impl))
+  {
+    ec = boost::asio::error::bad_descriptor;
+    return 0;
+  }
+
+  try
+  {
+    buffer_sequence_adapter<boost::asio::mutable_buffer,
+        boost::asio::mutable_buffers_1> bufs(boost::asio::buffer(data));
+
+    if (bufs.all_empty())
+    {
+      ec = boost::system::error_code();
+      return 0;
+    }
+
+    async_manager_.sync(
+        impl.socket_->InputStream->ReadAsync(
+          bufs.buffers()[0], bufs.buffers()[0]->Capacity,
+          Windows::Storage::Streams::InputStreamOptions::Partial), ec);
+
+    std::size_t bytes_transferred = bufs.buffers()[0]->Length;
+    if (bytes_transferred == 0 && !ec)
+    {
+      ec = boost::asio::error::eof;
+    }
+
+    return bytes_transferred;
+  }
+  catch (Platform::Exception^ e)
+  {
+    ec = boost::system::error_code(e->HResult,
+        boost::system::system_category());
+    return 0;
+  }
+}
+
+void winrt_ssocket_service_base::start_receive_op(
+      winrt_ssocket_service_base::base_implementation_type& impl,
+      const boost::asio::mutable_buffer& data, socket_base::message_flags flags,
+      winrt_async_op<Windows::Storage::Streams::IBuffer^>* op,
+      bool is_continuation)
+{
+  if (flags)
+  {
+    op->ec_ = boost::asio::error::operation_not_supported;
+    io_service_.post_immediate_completion(op, is_continuation);
+    return;
+  }
+
+  if (!is_open(impl))
+  {
+    op->ec_ = boost::asio::error::bad_descriptor;
+    io_service_.post_immediate_completion(op, is_continuation);
+    return;
+  }
+
+  try
+  {
+    buffer_sequence_adapter<boost::asio::mutable_buffer,
+        boost::asio::mutable_buffers_1> bufs(boost::asio::buffer(data));
+
+    if (bufs.all_empty())
+    {
+      io_service_.post_immediate_completion(op, is_continuation);
+      return;
+    }
+
+    async_manager_.async(
+        impl.socket_->InputStream->ReadAsync(
+          bufs.buffers()[0], bufs.buffers()[0]->Capacity,
+          Windows::Storage::Streams::InputStreamOptions::Partial), op);
+  }
+  catch (Platform::Exception^ e)
+  {
+    op->ec_ = boost::system::error_code(e->HResult,
+        boost::system::system_category());
+    io_service_.post_immediate_completion(op, is_continuation);
+  }
+}
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // defined(BOOST_ASIO_WINDOWS_RUNTIME)
+
+#endif // BOOST_ASIO_DETAIL_IMPL_WINRT_SSOCKET_SERVICE_BASE_IPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/winrt_timer_scheduler.hpp b/3rdParty/Boost/src/boost/asio/detail/impl/winrt_timer_scheduler.hpp
new file mode 100644
index 0000000..ff1ee03
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/winrt_timer_scheduler.hpp
@@ -0,0 +1,81 @@
+//
+// detail/impl/winrt_timer_scheduler.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_DETAIL_IMPL_WINRT_TIMER_SCHEDULER_HPP
+#define BOOST_ASIO_DETAIL_IMPL_WINRT_TIMER_SCHEDULER_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_WINDOWS_RUNTIME)
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+template <typename Time_Traits>
+void winrt_timer_scheduler::add_timer_queue(timer_queue<Time_Traits>& queue)
+{
+  do_add_timer_queue(queue);
+}
+
+// Remove a timer queue from the reactor.
+template <typename Time_Traits>
+void winrt_timer_scheduler::remove_timer_queue(timer_queue<Time_Traits>& queue)
+{
+  do_remove_timer_queue(queue);
+}
+
+template <typename Time_Traits>
+void winrt_timer_scheduler::schedule_timer(timer_queue<Time_Traits>& queue,
+    const typename Time_Traits::time_type& time,
+    typename timer_queue<Time_Traits>::per_timer_data& timer, wait_op* op)
+{
+  boost::asio::detail::mutex::scoped_lock lock(mutex_);
+
+  if (shutdown_)
+  {
+    io_service_.post_immediate_completion(op, false);
+    return;
+  }
+
+  bool earliest = queue.enqueue_timer(time, timer, op);
+  io_service_.work_started();
+  if (earliest)
+    event_.signal(lock);
+}
+
+template <typename Time_Traits>
+std::size_t winrt_timer_scheduler::cancel_timer(timer_queue<Time_Traits>& queue,
+    typename timer_queue<Time_Traits>::per_timer_data& timer,
+    std::size_t max_cancelled)
+{
+  boost::asio::detail::mutex::scoped_lock lock(mutex_);
+  op_queue<operation> ops;
+  std::size_t n = queue.cancel_timer(timer, ops, max_cancelled);
+  lock.unlock();
+  io_service_.post_deferred_completions(ops);
+  return n;
+}
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // defined(BOOST_ASIO_WINDOWS_RUNTIME)
+
+#endif // BOOST_ASIO_DETAIL_IMPL_WINRT_TIMER_SCHEDULER_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/winrt_timer_scheduler.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/winrt_timer_scheduler.ipp
new file mode 100644
index 0000000..ef480ea
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/winrt_timer_scheduler.ipp
@@ -0,0 +1,124 @@
+//
+// detail/impl/winrt_timer_scheduler.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_DETAIL_IMPL_WINRT_TIMER_SCHEDULER_IPP
+#define BOOST_ASIO_DETAIL_IMPL_WINRT_TIMER_SCHEDULER_IPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_WINDOWS_RUNTIME)
+
+#include <boost/asio/detail/bind_handler.hpp>
+#include <boost/asio/detail/winrt_timer_scheduler.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+winrt_timer_scheduler::winrt_timer_scheduler(
+    boost::asio::io_service& io_service)
+  : boost::asio::detail::service_base<winrt_timer_scheduler>(io_service),
+    io_service_(use_service<io_service_impl>(io_service)),
+    mutex_(),
+    event_(),
+    timer_queues_(),
+    thread_(0),
+    stop_thread_(false),
+    shutdown_(false)
+{
+  thread_ = new boost::asio::detail::thread(
+      bind_handler(&winrt_timer_scheduler::call_run_thread, this));
+}
+
+winrt_timer_scheduler::~winrt_timer_scheduler()
+{
+  shutdown_service();
+}
+
+void winrt_timer_scheduler::shutdown_service()
+{
+  boost::asio::detail::mutex::scoped_lock lock(mutex_);
+  shutdown_ = true;
+  stop_thread_ = true;
+  event_.signal(lock);
+  lock.unlock();
+
+  if (thread_)
+  {
+    thread_->join();
+    delete thread_;
+    thread_ = 0;
+  }
+
+  op_queue<operation> ops;
+  timer_queues_.get_all_timers(ops);
+  io_service_.abandon_operations(ops);
+}
+
+void winrt_timer_scheduler::fork_service(boost::asio::io_service::fork_event)
+{
+}
+
+void winrt_timer_scheduler::init_task()
+{
+}
+
+void winrt_timer_scheduler::run_thread()
+{
+  boost::asio::detail::mutex::scoped_lock lock(mutex_);
+  while (!stop_thread_)
+  {
+    const long max_wait_duration = 5 * 60 * 1000000;
+    long wait_duration = timer_queues_.wait_duration_usec(max_wait_duration);
+    event_.wait_for_usec(lock, wait_duration);
+    event_.clear(lock);
+    op_queue<operation> ops;
+    timer_queues_.get_ready_timers(ops);
+    if (!ops.empty())
+    {
+      lock.unlock();
+      io_service_.post_deferred_completions(ops);
+      lock.lock();
+    }
+  }
+}
+
+void winrt_timer_scheduler::call_run_thread(winrt_timer_scheduler* scheduler)
+{
+  scheduler->run_thread();
+}
+
+void winrt_timer_scheduler::do_add_timer_queue(timer_queue_base& queue)
+{
+  mutex::scoped_lock lock(mutex_);
+  timer_queues_.insert(&queue);
+}
+
+void winrt_timer_scheduler::do_remove_timer_queue(timer_queue_base& queue)
+{
+  mutex::scoped_lock lock(mutex_);
+  timer_queues_.erase(&queue);
+}
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // defined(BOOST_ASIO_WINDOWS_RUNTIME)
+
+#endif // BOOST_ASIO_DETAIL_IMPL_WINRT_TIMER_SCHEDULER_IPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/winsock_init.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/winsock_init.ipp
index 8916934..08f3280 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/winsock_init.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/winsock_init.ipp
@@ -1,11 +1,11 @@
 //
 // detail/impl/winsock_init.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_IMPL_WINSOCK_INIT_IPP
@@ -14,13 +14,13 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 
 #include <boost/asio/detail/socket_types.hpp>
 #include <boost/asio/detail/winsock_init.hpp>
 #include <boost/asio/detail/throw_error.hpp>
 #include <boost/asio/error.hpp>
 
@@ -38,20 +38,33 @@ void winsock_init_base::startup(data& d,
     WSADATA wsa_data;
     long result = ::WSAStartup(MAKEWORD(major, minor), &wsa_data);
     ::InterlockedExchange(&d.result_, result);
   }
 }
 
+void winsock_init_base::manual_startup(data& d)
+{
+  if (::InterlockedIncrement(&d.init_count_) == 1)
+  {
+    ::InterlockedExchange(&d.result_, 0);
+  }
+}
+
 void winsock_init_base::cleanup(data& d)
 {
   if (::InterlockedDecrement(&d.init_count_) == 0)
   {
     ::WSACleanup();
   }
 }
 
+void winsock_init_base::manual_cleanup(data& d)
+{
+  ::InterlockedDecrement(&d.init_count_);
+}
+
 void winsock_init_base::throw_on_error(data& d)
 {
   long result = ::InterlockedExchangeAdd(&d.result_, 0);
   if (result != 0)
   {
     boost::system::error_code ec(result,
@@ -63,9 +76,9 @@ void winsock_init_base::throw_on_error(data& d)
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
-#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 
 #endif // BOOST_ASIO_DETAIL_IMPL_WINSOCK_INIT_IPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/io_control.hpp b/3rdParty/Boost/src/boost/asio/detail/io_control.hpp
index e08a4fc..31d2f0e 100644
--- a/3rdParty/Boost/src/boost/asio/detail/io_control.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/io_control.hpp
@@ -1,11 +1,11 @@
 //
 // detail/io_control.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_IO_CONTROL_HPP
@@ -14,13 +14,12 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 #include <cstddef>
-#include <boost/config.hpp>
 #include <boost/asio/detail/socket_types.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
@@ -43,13 +42,13 @@ public:
   {
   }
 
   // Get the name of the IO control command.
   int name() const
   {
-    return static_cast<int>(FIONBIO);
+    return static_cast<int>(BOOST_ASIO_OS_DEF(FIONBIO));
   }
 
   // Set the value of the I/O control command.
   void set(bool value)
   {
     value_ = value ? 1 : 0;
@@ -93,13 +92,13 @@ public:
   {
   }
 
   // Get the name of the IO control command.
   int name() const
   {
-    return static_cast<int>(FIONREAD);
+    return static_cast<int>(BOOST_ASIO_OS_DEF(FIONREAD));
   }
 
   // Set the value of the I/O control command.
   void set(std::size_t value)
   {
     value_ = static_cast<detail::ioctl_arg_type>(value);
diff --git a/3rdParty/Boost/src/boost/asio/detail/keyword_tss_ptr.hpp b/3rdParty/Boost/src/boost/asio/detail/keyword_tss_ptr.hpp
index 10dd01a..cd32b50 100644
--- a/3rdParty/Boost/src/boost/asio/detail/keyword_tss_ptr.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/keyword_tss_ptr.hpp
@@ -1,11 +1,11 @@
 //
 // detail/keyword_tss_ptr.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_KEYWORD_TSS_PTR_HPP
@@ -52,17 +52,17 @@ public:
   void operator=(T* value)
   {
     value_ = value;
   }
 
 private:
-  static __thread T* value_;
+  static BOOST_ASIO_THREAD_KEYWORD T* value_;
 };
 
 template <typename T>
-__thread T* keyword_tss_ptr<T>::value_;
+BOOST_ASIO_THREAD_KEYWORD T* keyword_tss_ptr<T>::value_;
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
diff --git a/3rdParty/Boost/src/boost/asio/detail/kqueue_reactor.hpp b/3rdParty/Boost/src/boost/asio/detail/kqueue_reactor.hpp
index b3e111d..37c70b2 100644
--- a/3rdParty/Boost/src/boost/asio/detail/kqueue_reactor.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/kqueue_reactor.hpp
@@ -1,11 +1,11 @@
 //
 // detail/kqueue_reactor.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) 2005 Stefan Arentz (stefan at soze 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)
 //
 
@@ -17,26 +17,24 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
 #if defined(BOOST_ASIO_HAS_KQUEUE)
 
-#include <boost/limits.hpp>
 #include <cstddef>
 #include <sys/types.h>
 #include <sys/event.h>
 #include <sys/time.h>
-#include <boost/asio/detail/kqueue_reactor_fwd.hpp>
+#include <boost/asio/detail/limits.hpp>
 #include <boost/asio/detail/mutex.hpp>
 #include <boost/asio/detail/object_pool.hpp>
 #include <boost/asio/detail/op_queue.hpp>
 #include <boost/asio/detail/reactor_op.hpp>
 #include <boost/asio/detail/select_interrupter.hpp>
 #include <boost/asio/detail/socket_types.hpp>
 #include <boost/asio/detail/timer_queue_base.hpp>
-#include <boost/asio/detail/timer_queue_fwd.hpp>
 #include <boost/asio/detail/timer_queue_set.hpp>
 #include <boost/asio/detail/wait_op.hpp>
 #include <boost/asio/error.hpp>
 #include <boost/asio/io_service.hpp>
 
 // Older versions of Mac OS X may not define EV_OOBAND.
@@ -105,22 +103,22 @@ public:
   // Move descriptor registration from one descriptor_data object to another.
   BOOST_ASIO_DECL void move_descriptor(socket_type descriptor,
       per_descriptor_data& target_descriptor_data,
       per_descriptor_data& source_descriptor_data);
 
   // Post a reactor operation for immediate completion.
-  void post_immediate_completion(reactor_op* op)
+  void post_immediate_completion(reactor_op* op, bool is_continuation)
   {
-    io_service_.post_immediate_completion(op);
+    io_service_.post_immediate_completion(op, is_continuation);
   }
 
   // Start a new operation. The reactor operation will be performed when the
   // given descriptor is flagged as ready, or an error has occurred.
   BOOST_ASIO_DECL void start_op(int op_type, socket_type descriptor,
-      per_descriptor_data& descriptor_data,
-      reactor_op* op, bool allow_speculative);
+      per_descriptor_data& descriptor_data, reactor_op* op,
+      bool is_continuation, bool allow_speculative);
 
   // Cancel all operations associated with the given descriptor. The
   // handlers associated with the descriptor will be invoked with the
   // operation_aborted error.
   BOOST_ASIO_DECL void cancel_ops(socket_type descriptor,
       per_descriptor_data& descriptor_data);
diff --git a/3rdParty/Boost/src/boost/asio/detail/kqueue_reactor_fwd.hpp b/3rdParty/Boost/src/boost/asio/detail/kqueue_reactor_fwd.hpp
deleted file mode 100644
index 517a307..0000000
--- a/3rdParty/Boost/src/boost/asio/detail/kqueue_reactor_fwd.hpp
+++ /dev/null
@@ -1,35 +0,0 @@
-//
-// detail/kqueue_reactor_fwd.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-// Copyright (c) 2005 Stefan Arentz (stefan at soze 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_DETAIL_KQUEUE_REACTOR_FWD_HPP
-#define BOOST_ASIO_DETAIL_KQUEUE_REACTOR_FWD_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include <boost/asio/detail/config.hpp>
-
-#if defined(BOOST_ASIO_HAS_KQUEUE)
-
-namespace boost {
-namespace asio {
-namespace detail {
-
-class kqueue_reactor;
-
-} // namespace detail
-} // namespace asio
-} // namespace boost
-
-#endif // defined(BOOST_ASIO_HAS_KQUEUE)
-
-#endif // BOOST_ASIO_DETAIL_KQUEUE_REACTOR_FWD_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/limits.hpp b/3rdParty/Boost/src/boost/asio/detail/limits.hpp
new file mode 100644
index 0000000..036c599
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/detail/limits.hpp
@@ -0,0 +1,26 @@
+//
+// detail/limits.hpp
+// ~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2011 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_DETAIL_LIMITS_HPP
+#define BOOST_ASIO_DETAIL_LIMITS_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HAS_BOOST_LIMITS)
+# include <boost/limits.hpp>
+#else // defined(BOOST_ASIO_HAS_BOOST_LIMITS)
+# include <limits>
+#endif // defined(BOOST_ASIO_HAS_BOOST_LIMITS)
+
+#endif // BOOST_ASIO_DETAIL_LIMITS_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/macos_fenced_block.hpp b/3rdParty/Boost/src/boost/asio/detail/macos_fenced_block.hpp
index dc3b47d..aee4bfb 100644
--- a/3rdParty/Boost/src/boost/asio/detail/macos_fenced_block.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/macos_fenced_block.hpp
@@ -1,11 +1,11 @@
 //
 // detail/macos_fenced_block.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_MACOS_FENCED_BLOCK_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/mutex.hpp b/3rdParty/Boost/src/boost/asio/detail/mutex.hpp
index bd3e0c6..8212ec3 100644
--- a/3rdParty/Boost/src/boost/asio/detail/mutex.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/mutex.hpp
@@ -1,11 +1,11 @@
 //
 // detail/mutex.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_MUTEX_HPP
@@ -14,32 +14,36 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
-#if !defined(BOOST_HAS_THREADS) || defined(BOOST_ASIO_DISABLE_THREADS)
+#if !defined(BOOST_ASIO_HAS_THREADS)
 # include <boost/asio/detail/null_mutex.hpp>
-#elif defined(BOOST_WINDOWS)
+#elif defined(BOOST_ASIO_WINDOWS)
 # include <boost/asio/detail/win_mutex.hpp>
-#elif defined(BOOST_HAS_PTHREADS)
+#elif defined(BOOST_ASIO_HAS_PTHREADS)
 # include <boost/asio/detail/posix_mutex.hpp>
+#elif defined(BOOST_ASIO_HAS_STD_MUTEX_AND_CONDVAR)
+# include <boost/asio/detail/std_mutex.hpp>
 #else
-# error Only Windows and POSIX are supported!
+# error Only Windows, POSIX and std::mutex are supported!
 #endif
 
 namespace boost {
 namespace asio {
 namespace detail {
 
-#if !defined(BOOST_HAS_THREADS) || defined(BOOST_ASIO_DISABLE_THREADS)
+#if !defined(BOOST_ASIO_HAS_THREADS)
 typedef null_mutex mutex;
-#elif defined(BOOST_WINDOWS)
+#elif defined(BOOST_ASIO_WINDOWS)
 typedef win_mutex mutex;
-#elif defined(BOOST_HAS_PTHREADS)
+#elif defined(BOOST_ASIO_HAS_PTHREADS)
 typedef posix_mutex mutex;
+#elif defined(BOOST_ASIO_HAS_STD_MUTEX_AND_CONDVAR)
+typedef std_mutex mutex;
 #endif
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
diff --git a/3rdParty/Boost/src/boost/asio/detail/noncopyable.hpp b/3rdParty/Boost/src/boost/asio/detail/noncopyable.hpp
index 5f7e8cc..6aae476 100644
--- a/3rdParty/Boost/src/boost/asio/detail/noncopyable.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/noncopyable.hpp
@@ -1,11 +1,11 @@
 //
 // detail/noncopyable.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_NONCOPYABLE_HPP
@@ -13,38 +13,28 @@
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
-#include <boost/noncopyable.hpp>
-#include <boost/detail/workaround.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
-// Redefine the noncopyable class for Borland C++ since that compiler does not
-// apply the empty base optimisation unless the base class contains a dummy
-// char data member.
 class noncopyable
 {
 protected:
   noncopyable() {}
   ~noncopyable() {}
 private:
   noncopyable(const noncopyable&);
   const noncopyable& operator=(const noncopyable&);
-  char dummy_;
 };
-#else
-using boost::noncopyable;
-#endif
 
 } // namespace detail
 
 using boost::asio::detail::noncopyable;
 
 } // namespace asio
diff --git a/3rdParty/Boost/src/boost/asio/detail/null_event.hpp b/3rdParty/Boost/src/boost/asio/detail/null_event.hpp
index 1130d18..2e87844 100644
--- a/3rdParty/Boost/src/boost/asio/detail/null_event.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/null_event.hpp
@@ -1,11 +1,11 @@
 //
 // detail/null_event.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_NULL_EVENT_HPP
@@ -14,13 +14,13 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
-#if !defined(BOOST_HAS_THREADS) || defined(BOOST_ASIO_DISABLE_THREADS)
+#if !defined(BOOST_ASIO_HAS_THREADS)
 
 #include <boost/asio/detail/noncopyable.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
@@ -38,24 +38,37 @@ public:
 
   // Destructor.
   ~null_event()
   {
   }
 
-  // Signal the event.
+  // Signal the event. (Retained for backward compatibility.)
   template <typename Lock>
   void signal(Lock&)
   {
   }
 
-  // Signal the event and unlock the mutex.
+  // Signal all waiters.
   template <typename Lock>
-  void signal_and_unlock(Lock&)
+  void signal_all(Lock&)
   {
   }
 
+  // Unlock the mutex and signal one waiter.
+  template <typename Lock>
+  void unlock_and_signal_one(Lock&)
+  {
+  }
+
+  // If there's a waiter, unlock the mutex and signal it.
+  template <typename Lock>
+  bool maybe_unlock_and_signal_one(Lock&)
+  {
+    return false;
+  }
+
   // Reset the event.
   template <typename Lock>
   void clear(Lock&)
   {
   }
 
@@ -69,9 +82,9 @@ public:
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
-#endif // !defined(BOOST_HAS_THREADS) || defined(BOOST_ASIO_DISABLE_THREADS)
+#endif // !defined(BOOST_ASIO_HAS_THREADS)
 
 #endif // BOOST_ASIO_DETAIL_NULL_EVENT_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/null_fenced_block.hpp b/3rdParty/Boost/src/boost/asio/detail/null_fenced_block.hpp
index 64bedec..cf5da6e 100644
--- a/3rdParty/Boost/src/boost/asio/detail/null_fenced_block.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/null_fenced_block.hpp
@@ -1,11 +1,11 @@
 //
 // detail/null_fenced_block.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_NULL_FENCED_BLOCK_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/null_mutex.hpp b/3rdParty/Boost/src/boost/asio/detail/null_mutex.hpp
index 5d810bb..c282303 100644
--- a/3rdParty/Boost/src/boost/asio/detail/null_mutex.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/null_mutex.hpp
@@ -1,11 +1,11 @@
 //
 // detail/null_mutex.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_NULL_MUTEX_HPP
@@ -14,13 +14,13 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
-#if !defined(BOOST_HAS_THREADS) || defined(BOOST_ASIO_DISABLE_THREADS)
+#if !defined(BOOST_ASIO_HAS_THREADS)
 
 #include <boost/asio/detail/noncopyable.hpp>
 #include <boost/asio/detail/scoped_lock.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
@@ -58,9 +58,9 @@ public:
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
-#endif // !defined(BOOST_HAS_THREADS) || defined(BOOST_ASIO_DISABLE_THREADS)
+#endif // !defined(BOOST_ASIO_HAS_THREADS)
 
 #endif // BOOST_ASIO_DETAIL_NULL_MUTEX_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/null_reactor.hpp b/3rdParty/Boost/src/boost/asio/detail/null_reactor.hpp
new file mode 100644
index 0000000..a8e93e1
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/detail/null_reactor.hpp
@@ -0,0 +1,69 @@
+//
+// detail/null_reactor.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_DETAIL_NULL_REACTOR_HPP
+#define BOOST_ASIO_DETAIL_NULL_REACTOR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_WINDOWS_RUNTIME)
+
+#include <boost/asio/io_service.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+class null_reactor
+  : public boost::asio::detail::service_base<null_reactor>
+{
+public:
+  // Constructor.
+  null_reactor(boost::asio::io_service& io_service)
+    : boost::asio::detail::service_base<null_reactor>(io_service)
+  {
+  }
+
+  // Destructor.
+  ~null_reactor()
+  {
+  }
+
+  // Destroy all user-defined handler objects owned by the service.
+  void shutdown_service()
+  {
+  }
+
+  // No-op because should never be called.
+  void run(bool /*block*/, op_queue<operation>& /*ops*/)
+  {
+  }
+
+  // No-op.
+  void interrupt()
+  {
+  }
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // defined(BOOST_ASIO_WINDOWS_RUNTIME)
+
+#endif // BOOST_ASIO_DETAIL_NULL_REACTOR_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/null_signal_blocker.hpp b/3rdParty/Boost/src/boost/asio/detail/null_signal_blocker.hpp
index 5eeb293..89008fc 100644
--- a/3rdParty/Boost/src/boost/asio/detail/null_signal_blocker.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/null_signal_blocker.hpp
@@ -1,11 +1,11 @@
 //
 // detail/null_signal_blocker.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_NULL_SIGNAL_BLOCKER_HPP
@@ -14,15 +14,15 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
-#if !defined(BOOST_HAS_THREADS) \
-  || defined(BOOST_ASIO_DISABLE_THREADS) \
-  || defined(BOOST_WINDOWS) \
+#if !defined(BOOST_ASIO_HAS_THREADS) \
+  || defined(BOOST_ASIO_WINDOWS) \
+  || defined(BOOST_ASIO_WINDOWS_RUNTIME) \
   || defined(__CYGWIN__) \
   || defined(__SYMBIAN32__)
 
 #include <boost/asio/detail/noncopyable.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
@@ -59,13 +59,13 @@ public:
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
-#endif // !defined(BOOST_HAS_THREADS)
-       // || defined(BOOST_ASIO_DISABLE_THREADS)
-       // || defined(BOOST_WINDOWS)
+#endif // !defined(BOOST_ASIO_HAS_THREADS)
+       // || defined(BOOST_ASIO_WINDOWS)
+       // || defined(BOOST_ASIO_WINDOWS_RUNTIME)
        // || defined(__CYGWIN__)
        // || defined(__SYMBIAN32__)
 
 #endif // BOOST_ASIO_DETAIL_NULL_SIGNAL_BLOCKER_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/null_socket_service.hpp b/3rdParty/Boost/src/boost/asio/detail/null_socket_service.hpp
new file mode 100644
index 0000000..aafa1b7
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/detail/null_socket_service.hpp
@@ -0,0 +1,499 @@
+//
+// detail/null_socket_service.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_DETAIL_NULL_SOCKET_SERVICE_HPP
+#define BOOST_ASIO_DETAIL_NULL_SOCKET_SERVICE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_WINDOWS_RUNTIME)
+
+#include <boost/asio/buffer.hpp>
+#include <boost/asio/error.hpp>
+#include <boost/asio/io_service.hpp>
+#include <boost/asio/socket_base.hpp>
+#include <boost/asio/detail/bind_handler.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+template <typename Protocol>
+class null_socket_service
+{
+public:
+  // The protocol type.
+  typedef Protocol protocol_type;
+
+  // The endpoint type.
+  typedef typename Protocol::endpoint endpoint_type;
+
+  // The native type of a socket.
+  typedef int native_handle_type;
+
+  // The implementation type of the socket.
+  struct implementation_type
+  {
+  };
+
+  // Constructor.
+  null_socket_service(boost::asio::io_service& io_service)
+    : io_service_(io_service)
+  {
+  }
+
+  // Destroy all user-defined handler objects owned by the service.
+  void shutdown_service()
+  {
+  }
+
+  // Construct a new socket implementation.
+  void construct(implementation_type&)
+  {
+  }
+
+  // Move-construct a new socket implementation.
+  void move_construct(implementation_type&, implementation_type&)
+  {
+  }
+
+  // Move-assign from another socket implementation.
+  void move_assign(implementation_type&,
+      null_socket_service&, implementation_type&)
+  {
+  }
+
+  // Move-construct a new socket implementation from another protocol type.
+  template <typename Protocol1>
+  void converting_move_construct(implementation_type&,
+      typename null_socket_service<Protocol1>::implementation_type&)
+  {
+  }
+
+  // Destroy a socket implementation.
+  void destroy(implementation_type&)
+  {
+  }
+
+  // Open a new socket implementation.
+  boost::system::error_code open(implementation_type&,
+      const protocol_type&, boost::system::error_code& ec)
+  {
+    ec = boost::asio::error::operation_not_supported;
+    return ec;
+  }
+
+  // Assign a native socket to a socket implementation.
+  boost::system::error_code assign(implementation_type&, const protocol_type&,
+      const native_handle_type&, boost::system::error_code& ec)
+  {
+    ec = boost::asio::error::operation_not_supported;
+    return ec;
+  }
+
+  // Determine whether the socket is open.
+  bool is_open(const implementation_type&) const
+  {
+    return false;
+  }
+
+  // Destroy a socket implementation.
+  boost::system::error_code close(implementation_type&,
+      boost::system::error_code& ec)
+  {
+    ec = boost::asio::error::operation_not_supported;
+    return ec;
+  }
+
+  // Get the native socket representation.
+  native_handle_type native_handle(implementation_type&)
+  {
+    return 0;
+  }
+
+  // Cancel all operations associated with the socket.
+  boost::system::error_code cancel(implementation_type&,
+      boost::system::error_code& ec)
+  {
+    ec = boost::asio::error::operation_not_supported;
+    return ec;
+  }
+
+  // Determine whether the socket is at the out-of-band data mark.
+  bool at_mark(const implementation_type&,
+      boost::system::error_code& ec) const
+  {
+    ec = boost::asio::error::operation_not_supported;
+    return false;
+  }
+
+  // Determine the number of bytes available for reading.
+  std::size_t available(const implementation_type&,
+      boost::system::error_code& ec) const
+  {
+    ec = boost::asio::error::operation_not_supported;
+    return 0;
+  }
+
+  // Place the socket into the state where it will listen for new connections.
+  boost::system::error_code listen(implementation_type&,
+      int, boost::system::error_code& ec)
+  {
+    ec = boost::asio::error::operation_not_supported;
+    return ec;
+  }
+
+  // Perform an IO control command on the socket.
+  template <typename IO_Control_Command>
+  boost::system::error_code io_control(implementation_type&,
+      IO_Control_Command&, boost::system::error_code& ec)
+  {
+    ec = boost::asio::error::operation_not_supported;
+    return ec;
+  }
+
+  // Gets the non-blocking mode of the socket.
+  bool non_blocking(const implementation_type&) const
+  {
+    return false;
+  }
+
+  // Sets the non-blocking mode of the socket.
+  boost::system::error_code non_blocking(implementation_type&,
+      bool, boost::system::error_code& ec)
+  {
+    ec = boost::asio::error::operation_not_supported;
+    return ec;
+  }
+
+  // Gets the non-blocking mode of the native socket implementation.
+  bool native_non_blocking(const implementation_type&) const
+  {
+    return false;
+  }
+
+  // Sets the non-blocking mode of the native socket implementation.
+  boost::system::error_code native_non_blocking(implementation_type&,
+      bool, boost::system::error_code& ec)
+  {
+    ec = boost::asio::error::operation_not_supported;
+    return ec;
+  }
+
+  // Disable sends or receives on the socket.
+  boost::system::error_code shutdown(implementation_type&,
+      socket_base::shutdown_type, boost::system::error_code& ec)
+  {
+    ec = boost::asio::error::operation_not_supported;
+    return ec;
+  }
+
+  // Bind the socket to the specified local endpoint.
+  boost::system::error_code bind(implementation_type&,
+      const endpoint_type&, boost::system::error_code& ec)
+  {
+    ec = boost::asio::error::operation_not_supported;
+    return ec;
+  }
+
+  // Set a socket option.
+  template <typename Option>
+  boost::system::error_code set_option(implementation_type&,
+      const Option&, boost::system::error_code& ec)
+  {
+    ec = boost::asio::error::operation_not_supported;
+    return ec;
+  }
+
+  // Set a socket option.
+  template <typename Option>
+  boost::system::error_code get_option(const implementation_type&,
+      Option&, boost::system::error_code& ec) const
+  {
+    ec = boost::asio::error::operation_not_supported;
+    return ec;
+  }
+
+  // Get the local endpoint.
+  endpoint_type local_endpoint(const implementation_type&,
+      boost::system::error_code& ec) const
+  {
+    ec = boost::asio::error::operation_not_supported;
+    return endpoint_type();
+  }
+
+  // Get the remote endpoint.
+  endpoint_type remote_endpoint(const implementation_type&,
+      boost::system::error_code& ec) const
+  {
+    ec = boost::asio::error::operation_not_supported;
+    return endpoint_type();
+  }
+
+  // Send the given data to the peer.
+  template <typename ConstBufferSequence>
+  std::size_t send(implementation_type&, const ConstBufferSequence&,
+      socket_base::message_flags, boost::system::error_code& ec)
+  {
+    ec = boost::asio::error::operation_not_supported;
+    return 0;
+  }
+
+  // Wait until data can be sent without blocking.
+  std::size_t send(implementation_type&, const null_buffers&,
+      socket_base::message_flags, boost::system::error_code& ec)
+  {
+    ec = boost::asio::error::operation_not_supported;
+    return 0;
+  }
+
+  // Start an asynchronous send. The data being sent must be valid for the
+  // lifetime of the asynchronous operation.
+  template <typename ConstBufferSequence, typename Handler>
+  void async_send(implementation_type&, const ConstBufferSequence&,
+      socket_base::message_flags, Handler& handler)
+  {
+    boost::system::error_code ec = boost::asio::error::operation_not_supported;
+    const std::size_t bytes_transferred = 0;
+    io_service_.post(detail::bind_handler(handler, ec, bytes_transferred));
+  }
+
+  // Start an asynchronous wait until data can be sent without blocking.
+  template <typename Handler>
+  void async_send(implementation_type&, const null_buffers&,
+      socket_base::message_flags, Handler& handler)
+  {
+    boost::system::error_code ec = boost::asio::error::operation_not_supported;
+    const std::size_t bytes_transferred = 0;
+    io_service_.post(detail::bind_handler(handler, ec, bytes_transferred));
+  }
+
+  // Receive some data from the peer. Returns the number of bytes received.
+  template <typename MutableBufferSequence>
+  std::size_t receive(implementation_type&, const MutableBufferSequence&,
+      socket_base::message_flags, boost::system::error_code& ec)
+  {
+    ec = boost::asio::error::operation_not_supported;
+    return 0;
+  }
+
+  // Wait until data can be received without blocking.
+  std::size_t receive(implementation_type&, const null_buffers&,
+      socket_base::message_flags, boost::system::error_code& ec)
+  {
+    ec = boost::asio::error::operation_not_supported;
+    return 0;
+  }
+
+  // Start an asynchronous receive. The buffer for the data being received
+  // must be valid for the lifetime of the asynchronous operation.
+  template <typename MutableBufferSequence, typename Handler>
+  void async_receive(implementation_type&, const MutableBufferSequence&,
+      socket_base::message_flags, Handler& handler)
+  {
+    boost::system::error_code ec = boost::asio::error::operation_not_supported;
+    const std::size_t bytes_transferred = 0;
+    io_service_.post(detail::bind_handler(handler, ec, bytes_transferred));
+  }
+
+  // Wait until data can be received without blocking.
+  template <typename Handler>
+  void async_receive(implementation_type&, const null_buffers&,
+      socket_base::message_flags, Handler& handler)
+  {
+    boost::system::error_code ec = boost::asio::error::operation_not_supported;
+    const std::size_t bytes_transferred = 0;
+    io_service_.post(detail::bind_handler(handler, ec, bytes_transferred));
+  }
+
+  // Receive some data with associated flags. Returns the number of bytes
+  // received.
+  template <typename MutableBufferSequence>
+  std::size_t receive_with_flags(implementation_type&,
+      const MutableBufferSequence&, socket_base::message_flags,
+      socket_base::message_flags&, boost::system::error_code& ec)
+  {
+    ec = boost::asio::error::operation_not_supported;
+    return 0;
+  }
+
+  // Wait until data can be received without blocking.
+  std::size_t receive_with_flags(implementation_type&,
+      const null_buffers&, socket_base::message_flags,
+      socket_base::message_flags&, boost::system::error_code& ec)
+  {
+    ec = boost::asio::error::operation_not_supported;
+    return 0;
+  }
+
+  // Start an asynchronous receive. The buffer for the data being received
+  // must be valid for the lifetime of the asynchronous operation.
+  template <typename MutableBufferSequence, typename Handler>
+  void async_receive_with_flags(implementation_type&,
+      const MutableBufferSequence&, socket_base::message_flags,
+      socket_base::message_flags&, Handler& handler)
+  {
+    boost::system::error_code ec = boost::asio::error::operation_not_supported;
+    const std::size_t bytes_transferred = 0;
+    io_service_.post(detail::bind_handler(handler, ec, bytes_transferred));
+  }
+
+  // Wait until data can be received without blocking.
+  template <typename Handler>
+  void async_receive_with_flags(implementation_type&,
+      const null_buffers&, socket_base::message_flags,
+      socket_base::message_flags&, Handler& handler)
+  {
+    boost::system::error_code ec = boost::asio::error::operation_not_supported;
+    const std::size_t bytes_transferred = 0;
+    io_service_.post(detail::bind_handler(handler, ec, bytes_transferred));
+  }
+
+  // Send a datagram to the specified endpoint. Returns the number of bytes
+  // sent.
+  template <typename ConstBufferSequence>
+  std::size_t send_to(implementation_type&, const ConstBufferSequence&,
+      const endpoint_type&, socket_base::message_flags,
+      boost::system::error_code& ec)
+  {
+    ec = boost::asio::error::operation_not_supported;
+    return 0;
+  }
+
+  // Wait until data can be sent without blocking.
+  std::size_t send_to(implementation_type&, const null_buffers&,
+      const endpoint_type&, socket_base::message_flags,
+      boost::system::error_code& ec)
+  {
+    ec = boost::asio::error::operation_not_supported;
+    return 0;
+  }
+
+  // Start an asynchronous send. The data being sent must be valid for the
+  // lifetime of the asynchronous operation.
+  template <typename ConstBufferSequence, typename Handler>
+  void async_send_to(implementation_type&, const ConstBufferSequence&,
+      const endpoint_type&, socket_base::message_flags,
+      Handler& handler)
+  {
+    boost::system::error_code ec = boost::asio::error::operation_not_supported;
+    const std::size_t bytes_transferred = 0;
+    io_service_.post(detail::bind_handler(handler, ec, bytes_transferred));
+  }
+
+  // Start an asynchronous wait until data can be sent without blocking.
+  template <typename Handler>
+  void async_send_to(implementation_type&, const null_buffers&,
+      const endpoint_type&, socket_base::message_flags, Handler& handler)
+  {
+    boost::system::error_code ec = boost::asio::error::operation_not_supported;
+    const std::size_t bytes_transferred = 0;
+    io_service_.post(detail::bind_handler(handler, ec, bytes_transferred));
+  }
+
+  // Receive a datagram with the endpoint of the sender. Returns the number of
+  // bytes received.
+  template <typename MutableBufferSequence>
+  std::size_t receive_from(implementation_type&, const MutableBufferSequence&,
+      endpoint_type&, socket_base::message_flags,
+      boost::system::error_code& ec)
+  {
+    ec = boost::asio::error::operation_not_supported;
+    return 0;
+  }
+
+  // Wait until data can be received without blocking.
+  std::size_t receive_from(implementation_type&, const null_buffers&,
+      endpoint_type&, socket_base::message_flags,
+      boost::system::error_code& ec)
+  {
+    ec = boost::asio::error::operation_not_supported;
+    return 0;
+  }
+
+  // Start an asynchronous receive. The buffer for the data being received and
+  // the sender_endpoint object must both be valid for the lifetime of the
+  // asynchronous operation.
+  template <typename MutableBufferSequence, typename Handler>
+  void async_receive_from(implementation_type&,
+      const MutableBufferSequence&, endpoint_type&,
+      socket_base::message_flags, Handler& handler)
+  {
+    boost::system::error_code ec = boost::asio::error::operation_not_supported;
+    const std::size_t bytes_transferred = 0;
+    io_service_.post(detail::bind_handler(handler, ec, bytes_transferred));
+  }
+
+  // Wait until data can be received without blocking.
+  template <typename Handler>
+  void async_receive_from(implementation_type&,
+      const null_buffers&, endpoint_type&,
+      socket_base::message_flags, Handler& handler)
+  {
+    boost::system::error_code ec = boost::asio::error::operation_not_supported;
+    const std::size_t bytes_transferred = 0;
+    io_service_.post(detail::bind_handler(handler, ec, bytes_transferred));
+  }
+
+  // Accept a new connection.
+  template <typename Socket>
+  boost::system::error_code accept(implementation_type&,
+      Socket&, endpoint_type*, boost::system::error_code& ec)
+  {
+    ec = boost::asio::error::operation_not_supported;
+    return ec;
+  }
+
+  // Start an asynchronous accept. The peer and peer_endpoint objects
+  // must be valid until the accept's handler is invoked.
+  template <typename Socket, typename Handler>
+  void async_accept(implementation_type&, Socket&,
+      endpoint_type*, Handler& handler)
+  {
+    boost::system::error_code ec = boost::asio::error::operation_not_supported;
+    io_service_.post(detail::bind_handler(handler, ec));
+  }
+
+  // Connect the socket to the specified endpoint.
+  boost::system::error_code connect(implementation_type&,
+      const endpoint_type&, boost::system::error_code& ec)
+  {
+    ec = boost::asio::error::operation_not_supported;
+    return ec;
+  }
+
+  // Start an asynchronous connect.
+  template <typename Handler>
+  void async_connect(implementation_type&,
+      const endpoint_type&, Handler& handler)
+  {
+    boost::system::error_code ec = boost::asio::error::operation_not_supported;
+    io_service_.post(detail::bind_handler(handler, ec));
+  }
+
+private:
+  boost::asio::io_service& io_service_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // defined(BOOST_ASIO_WINDOWS_RUNTIME)
+
+#endif // BOOST_ASIO_DETAIL_NULL_SOCKET_SERVICE_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/null_static_mutex.hpp b/3rdParty/Boost/src/boost/asio/detail/null_static_mutex.hpp
index 3032896..201eefe 100644
--- a/3rdParty/Boost/src/boost/asio/detail/null_static_mutex.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/null_static_mutex.hpp
@@ -1,11 +1,11 @@
 //
 // detail/null_static_mutex.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_NULL_STATIC_MUTEX_HPP
@@ -14,13 +14,13 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
-#if !defined(BOOST_HAS_THREADS) || defined(BOOST_ASIO_DISABLE_THREADS)
+#if !defined(BOOST_ASIO_HAS_THREADS)
 
 #include <boost/asio/detail/scoped_lock.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
@@ -54,9 +54,9 @@ struct null_static_mutex
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
-#endif // !defined(BOOST_HAS_THREADS) || defined(BOOST_ASIO_DISABLE_THREADS)
+#endif // !defined(BOOST_ASIO_HAS_THREADS)
 
 #endif // BOOST_ASIO_DETAIL_NULL_STATIC_MUTEX_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/null_thread.hpp b/3rdParty/Boost/src/boost/asio/detail/null_thread.hpp
index 0212dbe..209ac23 100644
--- a/3rdParty/Boost/src/boost/asio/detail/null_thread.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/null_thread.hpp
@@ -1,11 +1,11 @@
 //
 // detail/null_thread.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_NULL_THREAD_HPP
@@ -14,13 +14,13 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
-#if !defined(BOOST_HAS_THREADS) || defined(BOOST_ASIO_DISABLE_THREADS)
+#if !defined(BOOST_ASIO_HAS_THREADS)
 
 #include <boost/asio/detail/noncopyable.hpp>
 #include <boost/asio/detail/throw_error.hpp>
 #include <boost/asio/error.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
@@ -55,9 +55,9 @@ public:
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
-#endif // !defined(BOOST_HAS_THREADS) || defined(BOOST_ASIO_DISABLE_THREADS)
+#endif // !defined(BOOST_ASIO_HAS_THREADS)
 
 #endif // BOOST_ASIO_DETAIL_NULL_THREAD_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/null_tss_ptr.hpp b/3rdParty/Boost/src/boost/asio/detail/null_tss_ptr.hpp
index 07be3e6..a8f4773 100644
--- a/3rdParty/Boost/src/boost/asio/detail/null_tss_ptr.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/null_tss_ptr.hpp
@@ -1,11 +1,11 @@
 //
 // detail/null_tss_ptr.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_NULL_TSS_PTR_HPP
@@ -14,13 +14,13 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
-#if !defined(BOOST_HAS_THREADS) || defined(BOOST_ASIO_DISABLE_THREADS)
+#if !defined(BOOST_ASIO_HAS_THREADS)
 
 #include <boost/asio/detail/noncopyable.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
@@ -62,9 +62,9 @@ private:
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
-#endif // !defined(BOOST_HAS_THREADS) || defined(BOOST_ASIO_DISABLE_THREADS)
+#endif // !defined(BOOST_ASIO_HAS_THREADS)
 
 #endif // BOOST_ASIO_DETAIL_NULL_TSS_PTR_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/object_pool.hpp b/3rdParty/Boost/src/boost/asio/detail/object_pool.hpp
index d315236..c2021a4 100644
--- a/3rdParty/Boost/src/boost/asio/detail/object_pool.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/object_pool.hpp
@@ -1,11 +1,11 @@
 //
 // detail/object_pool.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_OBJECT_POOL_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/old_win_sdk_compat.hpp b/3rdParty/Boost/src/boost/asio/detail/old_win_sdk_compat.hpp
index fcc27cf..df9f2ef 100644
--- a/3rdParty/Boost/src/boost/asio/detail/old_win_sdk_compat.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/old_win_sdk_compat.hpp
@@ -1,11 +1,11 @@
 //
 // detail/old_win_sdk_compat.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_OLD_WIN_SDK_COMPAT_HPP
@@ -14,13 +14,13 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 
 // Guess whether we are building against on old Platform SDK.
 #if !defined(IN6ADDR_ANY_INIT)
 #define BOOST_ASIO_HAS_OLD_WIN_SDK 1
 #endif // !defined(IN6ADDR_ANY_INIT)
 
@@ -208,9 +208,9 @@ struct addrinfo_emulation
 
 // Some SDKs (e.g. Windows CE) don't define IPPROTO_ICMPV6.
 #if !defined(IPPROTO_ICMPV6)
 # define IPPROTO_ICMPV6 58
 #endif
 
-#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 
 #endif // BOOST_ASIO_DETAIL_OLD_WIN_SDK_COMPAT_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/op_queue.hpp b/3rdParty/Boost/src/boost/asio/detail/op_queue.hpp
index ad61910..2b586dd 100644
--- a/3rdParty/Boost/src/boost/asio/detail/op_queue.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/op_queue.hpp
@@ -1,11 +1,11 @@
 //
 // detail/op_queue.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_OP_QUEUE_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/operation.hpp b/3rdParty/Boost/src/boost/asio/detail/operation.hpp
index 99371a9..d67dfa0 100644
--- a/3rdParty/Boost/src/boost/asio/detail/operation.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/operation.hpp
@@ -1,11 +1,11 @@
 //
 // detail/operation.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_OPERATION_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/pipe_select_interrupter.hpp b/3rdParty/Boost/src/boost/asio/detail/pipe_select_interrupter.hpp
index 0aee2a2..02a70ae 100644
--- a/3rdParty/Boost/src/boost/asio/detail/pipe_select_interrupter.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/pipe_select_interrupter.hpp
@@ -1,11 +1,11 @@
 //
 // detail/pipe_select_interrupter.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_PIPE_SELECT_INTERRUPTER_HPP
@@ -14,13 +14,14 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
-#if !defined(BOOST_WINDOWS)
+#if !defined(BOOST_ASIO_WINDOWS)
+#if !defined(BOOST_ASIO_WINDOWS_RUNTIME)
 #if !defined(__CYGWIN__)
 #if !defined(__SYMBIAN32__)
 #if !defined(BOOST_ASIO_HAS_EVENTFD)
 
 #include <boost/asio/detail/push_options.hpp>
 
@@ -81,9 +82,10 @@ private:
 # include <boost/asio/detail/impl/pipe_select_interrupter.ipp>
 #endif // defined(BOOST_ASIO_HEADER_ONLY)
 
 #endif // !defined(BOOST_ASIO_HAS_EVENTFD)
 #endif // !defined(__SYMBIAN32__)
 #endif // !defined(__CYGWIN__)
-#endif // !defined(BOOST_WINDOWS)
+#endif // !defined(BOOST_ASIO_WINDOWS_RUNTIME)
+#endif // !defined(BOOST_ASIO_WINDOWS)
 
 #endif // BOOST_ASIO_DETAIL_PIPE_SELECT_INTERRUPTER_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/pop_options.hpp b/3rdParty/Boost/src/boost/asio/detail/pop_options.hpp
index 6e78ddf..0dd9a45 100644
--- a/3rdParty/Boost/src/boost/asio/detail/pop_options.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/pop_options.hpp
@@ -1,11 +1,11 @@
 //
 // detail/pop_options.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)
 //
 
 // No header guard
@@ -92,7 +92,14 @@
 // Must remain the last #elif since some other vendors (Metrowerks, for example)
 // also #define _MSC_VER
 
 # pragma warning (pop)
 # pragma pack (pop)
 
+# if defined(__cplusplus_cli) || defined(__cplusplus_winrt)
+#  if defined(BOOST_ASIO_CLR_WORKAROUND)
+#   undef generic
+#   undef BOOST_ASIO_CLR_WORKAROUND
+#  endif
+# endif
+
 #endif
diff --git a/3rdParty/Boost/src/boost/asio/detail/posix_event.hpp b/3rdParty/Boost/src/boost/asio/detail/posix_event.hpp
index b77f384..9b633af 100644
--- a/3rdParty/Boost/src/boost/asio/detail/posix_event.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/posix_event.hpp
@@ -1,11 +1,11 @@
 //
 // detail/posix_event.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_POSIX_EVENT_HPP
@@ -14,16 +14,16 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
-#if defined(BOOST_HAS_PTHREADS) && !defined(BOOST_ASIO_DISABLE_THREADS)
+#if defined(BOOST_ASIO_HAS_PTHREADS)
 
-#include <boost/assert.hpp>
 #include <pthread.h>
+#include <boost/asio/detail/assert.hpp>
 #include <boost/asio/detail/noncopyable.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
@@ -39,62 +39,90 @@ public:
   // Destructor.
   ~posix_event()
   {
     ::pthread_cond_destroy(&cond_);
   }
 
-  // Signal the event.
+  // Signal the event. (Retained for backward compatibility.)
   template <typename Lock>
   void signal(Lock& lock)
   {
-    BOOST_ASSERT(lock.locked());
+    this->signal_all(lock);
+  }
+
+  // Signal all waiters.
+  template <typename Lock>
+  void signal_all(Lock& lock)
+  {
+    BOOST_ASIO_ASSERT(lock.locked());
     (void)lock;
-    signalled_ = true;
-    ::pthread_cond_signal(&cond_); // Ignore EINVAL.
+    state_ |= 1;
+    ::pthread_cond_broadcast(&cond_); // Ignore EINVAL.
   }
 
-  // Signal the event and unlock the mutex.
+  // Unlock the mutex and signal one waiter.
   template <typename Lock>
-  void signal_and_unlock(Lock& lock)
+  void unlock_and_signal_one(Lock& lock)
   {
-    BOOST_ASSERT(lock.locked());
-    signalled_ = true;
+    BOOST_ASIO_ASSERT(lock.locked());
+    state_ |= 1;
+    bool have_waiters = (state_ > 1);
     lock.unlock();
-    ::pthread_cond_signal(&cond_); // Ignore EINVAL.
+    if (have_waiters)
+      ::pthread_cond_signal(&cond_); // Ignore EINVAL.
+  }
+
+  // If there's a waiter, unlock the mutex and signal it.
+  template <typename Lock>
+  bool maybe_unlock_and_signal_one(Lock& lock)
+  {
+    BOOST_ASIO_ASSERT(lock.locked());
+    state_ |= 1;
+    if (state_ > 1)
+    {
+      lock.unlock();
+      ::pthread_cond_signal(&cond_); // Ignore EINVAL.
+      return true;
+    }
+    return false;
   }
 
   // Reset the event.
   template <typename Lock>
   void clear(Lock& lock)
   {
-    BOOST_ASSERT(lock.locked());
+    BOOST_ASIO_ASSERT(lock.locked());
     (void)lock;
-    signalled_ = false;
+    state_ &= ~std::size_t(1);
   }
 
   // Wait for the event to become signalled.
   template <typename Lock>
   void wait(Lock& lock)
   {
-    BOOST_ASSERT(lock.locked());
-    while (!signalled_)
+    BOOST_ASIO_ASSERT(lock.locked());
+    while ((state_ & 1) == 0)
+    {
+      state_ += 2;
       ::pthread_cond_wait(&cond_, &lock.mutex().mutex_); // Ignore EINVAL.
+      state_ -= 2;
+    }
   }
 
 private:
   ::pthread_cond_t cond_;
-  bool signalled_;
+  std::size_t state_;
 };
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #if defined(BOOST_ASIO_HEADER_ONLY)
 # include <boost/asio/detail/impl/posix_event.ipp>
 #endif // defined(BOOST_ASIO_HEADER_ONLY)
 
-#endif // defined(BOOST_HAS_PTHREADS) && !defined(BOOST_ASIO_DISABLE_THREADS)
+#endif // defined(BOOST_ASIO_HAS_PTHREADS)
 
 #endif // BOOST_ASIO_DETAIL_POSIX_EVENT_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/posix_fd_set_adapter.hpp b/3rdParty/Boost/src/boost/asio/detail/posix_fd_set_adapter.hpp
index f6476e6..267c983 100644
--- a/3rdParty/Boost/src/boost/asio/detail/posix_fd_set_adapter.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/posix_fd_set_adapter.hpp
@@ -1,11 +1,11 @@
 //
 // detail/posix_fd_set_adapter.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_POSIX_FD_SET_ADAPTER_HPP
@@ -14,16 +14,19 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
-#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+#if !defined(BOOST_ASIO_WINDOWS) \
+  && !defined(__CYGWIN__) \
+  && !defined(BOOST_ASIO_WINDOWS_RUNTIME)
 
 #include <cstring>
 #include <boost/asio/detail/noncopyable.hpp>
+#include <boost/asio/detail/reactor_op_queue.hpp>
 #include <boost/asio/detail/socket_types.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
@@ -55,12 +58,26 @@ public:
       FD_SET(descriptor, &fd_set_);
       return true;
     }
     return false;
   }
 
+  void set(reactor_op_queue<socket_type>& operations, op_queue<operation>& ops)
+  {
+    reactor_op_queue<socket_type>::iterator i = operations.begin();
+    while (i != operations.end())
+    {
+      reactor_op_queue<socket_type>::iterator op_iter = i++;
+      if (!set(op_iter->first))
+      {
+        boost::system::error_code ec(error::fd_set_failure);
+        operations.cancel_operations(op_iter, ops, ec);
+      }
+    }
+  }
+
   bool is_set(socket_type descriptor) const
   {
     return FD_ISSET(descriptor, &fd_set_) != 0;
   }
 
   operator fd_set*()
@@ -70,20 +87,34 @@ public:
 
   socket_type max_descriptor() const
   {
     return max_descriptor_;
   }
 
+  void perform(reactor_op_queue<socket_type>& operations,
+      op_queue<operation>& ops) const
+  {
+    reactor_op_queue<socket_type>::iterator i = operations.begin();
+    while (i != operations.end())
+    {
+      reactor_op_queue<socket_type>::iterator op_iter = i++;
+      if (is_set(op_iter->first))
+        operations.perform_operations(op_iter, ops);
+    }
+  }
+
 private:
   mutable fd_set fd_set_;
   socket_type max_descriptor_;
 };
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
-#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+#endif // !defined(BOOST_ASIO_WINDOWS)
+       // && !defined(__CYGWIN__)
+       // && !defined(BOOST_ASIO_WINDOWS_RUNTIME)
 
 #endif // BOOST_ASIO_DETAIL_POSIX_FD_SET_ADAPTER_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/posix_mutex.hpp b/3rdParty/Boost/src/boost/asio/detail/posix_mutex.hpp
index a456c2a..7db2231 100644
--- a/3rdParty/Boost/src/boost/asio/detail/posix_mutex.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/posix_mutex.hpp
@@ -1,11 +1,11 @@
 //
 // detail/posix_mutex.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_POSIX_MUTEX_HPP
@@ -14,13 +14,13 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
-#if defined(BOOST_HAS_PTHREADS) && !defined(BOOST_ASIO_DISABLE_THREADS)
+#if defined(BOOST_ASIO_HAS_PTHREADS)
 
 #include <pthread.h>
 #include <boost/asio/detail/noncopyable.hpp>
 #include <boost/asio/detail/scoped_lock.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
@@ -70,9 +70,9 @@ private:
 #include <boost/asio/detail/pop_options.hpp>
 
 #if defined(BOOST_ASIO_HEADER_ONLY)
 # include <boost/asio/detail/impl/posix_mutex.ipp>
 #endif // defined(BOOST_ASIO_HEADER_ONLY)
 
-#endif // defined(BOOST_HAS_PTHREADS) && !defined(BOOST_ASIO_DISABLE_THREADS)
+#endif // defined(BOOST_ASIO_HAS_PTHREADS)
 
 #endif // BOOST_ASIO_DETAIL_POSIX_MUTEX_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/posix_signal_blocker.hpp b/3rdParty/Boost/src/boost/asio/detail/posix_signal_blocker.hpp
index 0347778..e069897 100644
--- a/3rdParty/Boost/src/boost/asio/detail/posix_signal_blocker.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/posix_signal_blocker.hpp
@@ -1,11 +1,11 @@
 //
 // detail/posix_signal_blocker.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_POSIX_SIGNAL_BLOCKER_HPP
@@ -14,13 +14,13 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
-#if defined(BOOST_HAS_PTHREADS) && !defined(BOOST_ASIO_DISABLE_THREADS)
+#if defined(BOOST_ASIO_HAS_PTHREADS)
 
 #include <csignal>
 #include <pthread.h>
 #include <signal.h>
 #include <boost/asio/detail/noncopyable.hpp>
 
@@ -79,9 +79,9 @@ private:
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
-#endif // defined(BOOST_HAS_PTHREADS) && !defined(BOOST_ASIO_DISABLE_THREADS)
+#endif // defined(BOOST_ASIO_HAS_PTHREADS)
 
 #endif // BOOST_ASIO_DETAIL_POSIX_SIGNAL_BLOCKER_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/posix_static_mutex.hpp b/3rdParty/Boost/src/boost/asio/detail/posix_static_mutex.hpp
index a27d9d8..a9c278c 100644
--- a/3rdParty/Boost/src/boost/asio/detail/posix_static_mutex.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/posix_static_mutex.hpp
@@ -1,11 +1,11 @@
 //
 // detail/posix_static_mutex.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_POSIX_STATIC_MUTEX_HPP
@@ -14,13 +14,13 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
-#if defined(BOOST_HAS_PTHREADS) && !defined(BOOST_ASIO_DISABLE_THREADS)
+#if defined(BOOST_ASIO_HAS_PTHREADS)
 
 #include <pthread.h>
 #include <boost/asio/detail/scoped_lock.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
@@ -58,9 +58,9 @@ struct posix_static_mutex
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
-#endif // defined(BOOST_HAS_PTHREADS) && !defined(BOOST_ASIO_DISABLE_THREADS)
+#endif // defined(BOOST_ASIO_HAS_PTHREADS)
 
 #endif // BOOST_ASIO_DETAIL_POSIX_STATIC_MUTEX_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/posix_thread.hpp b/3rdParty/Boost/src/boost/asio/detail/posix_thread.hpp
index 44bf62c..cf40c9d 100644
--- a/3rdParty/Boost/src/boost/asio/detail/posix_thread.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/posix_thread.hpp
@@ -1,11 +1,11 @@
 //
 // detail/posix_thread.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_POSIX_THREAD_HPP
@@ -14,13 +14,13 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
-#if defined(BOOST_HAS_PTHREADS) && !defined(BOOST_ASIO_DISABLE_THREADS)
+#if defined(BOOST_ASIO_HAS_PTHREADS)
 
 #include <pthread.h>
 #include <boost/asio/detail/noncopyable.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
@@ -99,9 +99,9 @@ private:
 #include <boost/asio/detail/pop_options.hpp>
 
 #if defined(BOOST_ASIO_HEADER_ONLY)
 # include <boost/asio/detail/impl/posix_thread.ipp>
 #endif // defined(BOOST_ASIO_HEADER_ONLY)
 
-#endif // defined(BOOST_HAS_PTHREADS) && !defined(BOOST_ASIO_DISABLE_THREADS)
+#endif // defined(BOOST_ASIO_HAS_PTHREADS)
 
 #endif // BOOST_ASIO_DETAIL_POSIX_THREAD_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/posix_tss_ptr.hpp b/3rdParty/Boost/src/boost/asio/detail/posix_tss_ptr.hpp
index 33ac502..10abe82 100644
--- a/3rdParty/Boost/src/boost/asio/detail/posix_tss_ptr.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/posix_tss_ptr.hpp
@@ -1,11 +1,11 @@
 //
 // detail/posix_tss_ptr.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_POSIX_TSS_PTR_HPP
@@ -14,13 +14,13 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
-#if defined(BOOST_HAS_PTHREADS) && !defined(BOOST_ASIO_DISABLE_THREADS)
+#if defined(BOOST_ASIO_HAS_PTHREADS)
 
 #include <pthread.h>
 #include <boost/asio/detail/noncopyable.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
@@ -61,22 +61,21 @@ public:
   }
 
 private:
   // Thread-specific storage to allow unlocked access to determine whether a
   // thread is a member of the pool.
   pthread_key_t tss_key_;
-
 };
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #if defined(BOOST_ASIO_HEADER_ONLY)
 # include <boost/asio/detail/impl/posix_tss_ptr.ipp>
 #endif // defined(BOOST_ASIO_HEADER_ONLY)
 
-#endif // defined(BOOST_HAS_PTHREADS) && !defined(BOOST_ASIO_DISABLE_THREADS)
+#endif // defined(BOOST_ASIO_HAS_PTHREADS)
 
 #endif // BOOST_ASIO_DETAIL_POSIX_TSS_PTR_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/push_options.hpp b/3rdParty/Boost/src/boost/asio/detail/push_options.hpp
index fef517d..ad72bfb 100644
--- a/3rdParty/Boost/src/boost/asio/detail/push_options.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/push_options.hpp
@@ -1,11 +1,11 @@
 //
 // detail/push_options.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)
 //
 
 // No header guard
@@ -100,13 +100,15 @@
 # pragma warning (disable:4103)
 # pragma warning (push)
 # pragma warning (disable:4127)
 # pragma warning (disable:4180)
 # pragma warning (disable:4244)
 # pragma warning (disable:4355)
+# pragma warning (disable:4510)
 # pragma warning (disable:4512)
+# pragma warning (disable:4610)
 # pragma warning (disable:4675)
 # if defined(_M_IX86) && defined(_Wp64)
 // The /Wp64 option is broken. If you want to check 64 bit portability, use a
 // 64 bit compiler!
 #  pragma warning (disable:4311)
 #  pragma warning (disable:4312)
@@ -121,7 +123,16 @@
 #  pragma optimize ("g", off)
 # endif
 # if !defined(_MT)
 #  error Multithreaded RTL must be selected.
 # endif // !defined(_MT)
 
+# if defined(__cplusplus_cli) || defined(__cplusplus_winrt)
+#  if !defined(BOOST_ASIO_DISABLE_CLR_WORKAROUND)
+#   if !defined(generic)
+#    define generic cpp_generic
+#    define BOOST_ASIO_CLR_WORKAROUND
+#   endif
+#  endif
+# endif
+
 #endif
diff --git a/3rdParty/Boost/src/boost/asio/detail/reactive_descriptor_service.hpp b/3rdParty/Boost/src/boost/asio/detail/reactive_descriptor_service.hpp
index 5efb24b..10b2f3f 100644
--- a/3rdParty/Boost/src/boost/asio/detail/reactive_descriptor_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/reactive_descriptor_service.hpp
@@ -1,11 +1,11 @@
 //
 // detail/reactive_descriptor_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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_REACTIVE_DESCRIPTOR_SERVICE_HPP
@@ -14,17 +14,19 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
-#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+#if !defined(BOOST_ASIO_WINDOWS) \
+  && !defined(BOOST_ASIO_WINDOWS_RUNTIME) \
+  && !defined(__CYGWIN__)
 
-#include <boost/utility/addressof.hpp>
 #include <boost/asio/buffer.hpp>
 #include <boost/asio/io_service.hpp>
+#include <boost/asio/detail/addressof.hpp>
 #include <boost/asio/detail/bind_handler.hpp>
 #include <boost/asio/detail/buffer_sequence_adapter.hpp>
 #include <boost/asio/detail/descriptor_ops.hpp>
 #include <boost/asio/detail/descriptor_read_op.hpp>
 #include <boost/asio/detail/descriptor_write_op.hpp>
 #include <boost/asio/detail/fenced_block.hpp>
@@ -183,45 +185,51 @@ public:
   }
 
   // Start an asynchronous write. The data being sent must be valid for the
   // lifetime of the asynchronous operation.
   template <typename ConstBufferSequence, typename Handler>
   void async_write_some(implementation_type& impl,
-      const ConstBufferSequence& buffers, Handler handler)
+      const ConstBufferSequence& buffers, Handler& handler)
   {
+    bool is_continuation =
+      boost_asio_handler_cont_helpers::is_continuation(handler);
+
     // Allocate and construct an operation to wrap the handler.
     typedef descriptor_write_op<ConstBufferSequence, Handler> op;
-    typename op::ptr p = { boost::addressof(handler),
+    typename op::ptr p = { boost::asio::detail::addressof(handler),
       boost_asio_handler_alloc_helpers::allocate(
         sizeof(op), handler), 0 };
     p.p = new (p.v) op(impl.descriptor_, buffers, handler);
 
     BOOST_ASIO_HANDLER_CREATION((p.p, "descriptor", &impl, "async_write_some"));
 
-    start_op(impl, reactor::write_op, p.p, true,
+    start_op(impl, reactor::write_op, p.p, is_continuation, true,
         buffer_sequence_adapter<boost::asio::const_buffer,
           ConstBufferSequence>::all_empty(buffers));
     p.v = p.p = 0;
   }
 
   // Start an asynchronous wait until data can be written without blocking.
   template <typename Handler>
   void async_write_some(implementation_type& impl,
-      const null_buffers&, Handler handler)
+      const null_buffers&, Handler& handler)
   {
+    bool is_continuation =
+      boost_asio_handler_cont_helpers::is_continuation(handler);
+
     // Allocate and construct an operation to wrap the handler.
     typedef reactive_null_buffers_op<Handler> op;
-    typename op::ptr p = { boost::addressof(handler),
+    typename op::ptr p = { boost::asio::detail::addressof(handler),
       boost_asio_handler_alloc_helpers::allocate(
         sizeof(op), handler), 0 };
     p.p = new (p.v) op(handler);
 
     BOOST_ASIO_HANDLER_CREATION((p.p, "descriptor",
           &impl, "async_write_some(null_buffers)"));
 
-    start_op(impl, reactor::write_op, p.p, false, false);
+    start_op(impl, reactor::write_op, p.p, is_continuation, false, false);
     p.v = p.p = 0;
   }
 
   // Read some data from the stream. Returns the number of bytes read.
   template <typename MutableBufferSequence>
   size_t read_some(implementation_type& impl,
@@ -245,52 +253,58 @@ public:
   }
 
   // Start an asynchronous read. The buffer for the data being read must be
   // valid for the lifetime of the asynchronous operation.
   template <typename MutableBufferSequence, typename Handler>
   void async_read_some(implementation_type& impl,
-      const MutableBufferSequence& buffers, Handler handler)
+      const MutableBufferSequence& buffers, Handler& handler)
   {
+    bool is_continuation =
+      boost_asio_handler_cont_helpers::is_continuation(handler);
+
     // Allocate and construct an operation to wrap the handler.
     typedef descriptor_read_op<MutableBufferSequence, Handler> op;
-    typename op::ptr p = { boost::addressof(handler),
+    typename op::ptr p = { boost::asio::detail::addressof(handler),
       boost_asio_handler_alloc_helpers::allocate(
         sizeof(op), handler), 0 };
     p.p = new (p.v) op(impl.descriptor_, buffers, handler);
 
     BOOST_ASIO_HANDLER_CREATION((p.p, "descriptor", &impl, "async_read_some"));
 
-    start_op(impl, reactor::read_op, p.p, true,
+    start_op(impl, reactor::read_op, p.p, is_continuation, true,
         buffer_sequence_adapter<boost::asio::mutable_buffer,
           MutableBufferSequence>::all_empty(buffers));
     p.v = p.p = 0;
   }
 
   // Wait until data can be read without blocking.
   template <typename Handler>
   void async_read_some(implementation_type& impl,
-      const null_buffers&, Handler handler)
+      const null_buffers&, Handler& handler)
   {
+    bool is_continuation =
+      boost_asio_handler_cont_helpers::is_continuation(handler);
+
     // Allocate and construct an operation to wrap the handler.
     typedef reactive_null_buffers_op<Handler> op;
-    typename op::ptr p = { boost::addressof(handler),
+    typename op::ptr p = { boost::asio::detail::addressof(handler),
       boost_asio_handler_alloc_helpers::allocate(
         sizeof(op), handler), 0 };
     p.p = new (p.v) op(handler);
 
     BOOST_ASIO_HANDLER_CREATION((p.p, "descriptor",
           &impl, "async_read_some(null_buffers)"));
 
-    start_op(impl, reactor::read_op, p.p, false, false);
+    start_op(impl, reactor::read_op, p.p, is_continuation, false, false);
     p.v = p.p = 0;
   }
 
 private:
   // Start the asynchronous operation.
   BOOST_ASIO_DECL void start_op(implementation_type& impl, int op_type,
-      reactor_op* op, bool is_non_blocking, bool noop);
+      reactor_op* op, bool is_continuation, bool is_non_blocking, bool noop);
 
   // The selector that performs event demultiplexing for the service.
   reactor& reactor_;
 };
 
 } // namespace detail
@@ -300,9 +314,11 @@ private:
 #include <boost/asio/detail/pop_options.hpp>
 
 #if defined(BOOST_ASIO_HEADER_ONLY)
 # include <boost/asio/detail/impl/reactive_descriptor_service.ipp>
 #endif // defined(BOOST_ASIO_HEADER_ONLY)
 
-#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+#endif // !defined(BOOST_ASIO_WINDOWS)
+       //   && !defined(BOOST_ASIO_WINDOWS_RUNTIME)
+       //   && !defined(__CYGWIN__)
 
 #endif // BOOST_ASIO_DETAIL_REACTIVE_DESCRIPTOR_SERVICE_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/reactive_null_buffers_op.hpp b/3rdParty/Boost/src/boost/asio/detail/reactive_null_buffers_op.hpp
index 3881e96..39aaa60 100644
--- a/3rdParty/Boost/src/boost/asio/detail/reactive_null_buffers_op.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/reactive_null_buffers_op.hpp
@@ -1,11 +1,11 @@
 //
 // detail/reactive_null_buffers_op.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_REACTIVE_NULL_BUFFERS_OP_HPP
@@ -13,13 +13,13 @@
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
-#include <boost/utility/addressof.hpp>
+#include <boost/asio/detail/addressof.hpp>
 #include <boost/asio/detail/fenced_block.hpp>
 #include <boost/asio/detail/handler_alloc_helpers.hpp>
 #include <boost/asio/detail/handler_invoke_helpers.hpp>
 #include <boost/asio/detail/reactor_op.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
@@ -49,25 +49,25 @@ public:
   static void do_complete(io_service_impl* owner, operation* base,
       const boost::system::error_code& /*ec*/,
       std::size_t /*bytes_transferred*/)
   {
     // Take ownership of the handler object.
     reactive_null_buffers_op* o(static_cast<reactive_null_buffers_op*>(base));
-    ptr p = { boost::addressof(o->handler_), o, o };
+    ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
 
     BOOST_ASIO_HANDLER_COMPLETION((o));
 
     // Make a copy of the handler so that the memory can be deallocated before
     // the upcall is made. Even if we're not about to make an upcall, a
     // sub-object of the handler may be the true owner of the memory associated
     // with the handler. Consequently, a local copy of the handler is required
     // to ensure that any owning sub-object remains valid until after we have
     // deallocated the memory here.
     detail::binder2<Handler, boost::system::error_code, std::size_t>
       handler(o->handler_, o->ec_, o->bytes_transferred_);
-    p.h = boost::addressof(handler.handler_);
+    p.h = boost::asio::detail::addressof(handler.handler_);
     p.reset();
 
     // Make the upcall if required.
     if (owner)
     {
       fenced_block b(fenced_block::half);
diff --git a/3rdParty/Boost/src/boost/asio/detail/reactive_serial_port_service.hpp b/3rdParty/Boost/src/boost/asio/detail/reactive_serial_port_service.hpp
index a32088f..86d8300 100644
--- a/3rdParty/Boost/src/boost/asio/detail/reactive_serial_port_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/reactive_serial_port_service.hpp
@@ -1,11 +1,11 @@
 //
 // detail/reactive_serial_port_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)
 // Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.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,13 +16,13 @@
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
 #if defined(BOOST_ASIO_HAS_SERIAL_PORT)
-#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+#if !defined(BOOST_ASIO_WINDOWS) && !defined(__CYGWIN__)
 
 #include <string>
 #include <boost/asio/error.hpp>
 #include <boost/asio/io_service.hpp>
 #include <boost/asio/serial_port_base.hpp>
 #include <boost/asio/detail/descriptor_ops.hpp>
@@ -155,13 +155,13 @@ public:
   }
 
   // Start an asynchronous write. The data being written must be valid for the
   // lifetime of the asynchronous operation.
   template <typename ConstBufferSequence, typename Handler>
   void async_write_some(implementation_type& impl,
-      const ConstBufferSequence& buffers, Handler handler)
+      const ConstBufferSequence& buffers, Handler& handler)
   {
     descriptor_service_.async_write_some(impl, buffers, handler);
   }
 
   // Read some data. Returns the number of bytes received.
   template <typename MutableBufferSequence>
@@ -172,13 +172,13 @@ public:
   }
 
   // Start an asynchronous read. The buffer for the data being received must be
   // valid for the lifetime of the asynchronous operation.
   template <typename MutableBufferSequence, typename Handler>
   void async_read_some(implementation_type& impl,
-      const MutableBufferSequence& buffers, Handler handler)
+      const MutableBufferSequence& buffers, Handler& handler)
   {
     descriptor_service_.async_read_some(impl, buffers, handler);
   }
 
 private:
   // Function pointer type for storing a serial port option.
@@ -227,10 +227,10 @@ private:
 #include <boost/asio/detail/pop_options.hpp>
 
 #if defined(BOOST_ASIO_HEADER_ONLY)
 # include <boost/asio/detail/impl/reactive_serial_port_service.ipp>
 #endif // defined(BOOST_ASIO_HEADER_ONLY)
 
-#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+#endif // !defined(BOOST_ASIO_WINDOWS) && !defined(__CYGWIN__)
 #endif // defined(BOOST_ASIO_HAS_SERIAL_PORT)
 
 #endif // BOOST_ASIO_DETAIL_REACTIVE_SERIAL_PORT_SERVICE_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/reactive_socket_accept_op.hpp b/3rdParty/Boost/src/boost/asio/detail/reactive_socket_accept_op.hpp
index d80bdea..93ece02 100644
--- a/3rdParty/Boost/src/boost/asio/detail/reactive_socket_accept_op.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/reactive_socket_accept_op.hpp
@@ -1,11 +1,11 @@
 //
 // detail/reactive_socket_accept_op.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_REACTIVE_SOCKET_ACCEPT_OP_HPP
@@ -13,13 +13,13 @@
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
-#include <boost/utility/addressof.hpp>
+#include <boost/asio/detail/addressof.hpp>
 #include <boost/asio/detail/bind_handler.hpp>
 #include <boost/asio/detail/buffer_sequence_adapter.hpp>
 #include <boost/asio/detail/fenced_block.hpp>
 #include <boost/asio/detail/reactor_op.hpp>
 #include <boost/asio/detail/socket_holder.hpp>
 #include <boost/asio/detail/socket_ops.hpp>
@@ -55,13 +55,13 @@ public:
     socket_type new_socket = invalid_socket;
     bool result = socket_ops::non_blocking_accept(o->socket_,
           o->state_, o->peer_endpoint_ ? o->peer_endpoint_->data() : 0,
           o->peer_endpoint_ ? &addrlen : 0, o->ec_, new_socket);
 
     // On success, assign new connection to peer socket object.
-    if (new_socket >= 0)
+    if (new_socket != invalid_socket)
     {
       socket_holder new_socket_holder(new_socket);
       if (o->peer_endpoint_)
         o->peer_endpoint_->resize(addrlen);
       if (!o->peer_.assign(o->protocol_, new_socket, o->ec_))
         new_socket_holder.release();
@@ -97,25 +97,25 @@ public:
   static void do_complete(io_service_impl* owner, operation* base,
       const boost::system::error_code& /*ec*/,
       std::size_t /*bytes_transferred*/)
   {
     // Take ownership of the handler object.
     reactive_socket_accept_op* o(static_cast<reactive_socket_accept_op*>(base));
-    ptr p = { boost::addressof(o->handler_), o, o };
+    ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
 
     BOOST_ASIO_HANDLER_COMPLETION((o));
 
     // Make a copy of the handler so that the memory can be deallocated before
     // the upcall is made. Even if we're not about to make an upcall, a
     // sub-object of the handler may be the true owner of the memory associated
     // with the handler. Consequently, a local copy of the handler is required
     // to ensure that any owning sub-object remains valid until after we have
     // deallocated the memory here.
     detail::binder1<Handler, boost::system::error_code>
       handler(o->handler_, o->ec_);
-    p.h = boost::addressof(handler.handler_);
+    p.h = boost::asio::detail::addressof(handler.handler_);
     p.reset();
 
     // Make the upcall if required.
     if (owner)
     {
       fenced_block b(fenced_block::half);
diff --git a/3rdParty/Boost/src/boost/asio/detail/reactive_socket_connect_op.hpp b/3rdParty/Boost/src/boost/asio/detail/reactive_socket_connect_op.hpp
index 6463a03..254c9f4 100644
--- a/3rdParty/Boost/src/boost/asio/detail/reactive_socket_connect_op.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/reactive_socket_connect_op.hpp
@@ -1,11 +1,11 @@
 //
 // detail/reactive_socket_connect_op.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_REACTIVE_SOCKET_CONNECT_OP_HPP
@@ -13,13 +13,13 @@
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
-#include <boost/utility/addressof.hpp>
+#include <boost/asio/detail/addressof.hpp>
 #include <boost/asio/detail/bind_handler.hpp>
 #include <boost/asio/detail/buffer_sequence_adapter.hpp>
 #include <boost/asio/detail/fenced_block.hpp>
 #include <boost/asio/detail/reactor_op.hpp>
 #include <boost/asio/detail/socket_ops.hpp>
 
@@ -67,25 +67,25 @@ public:
       const boost::system::error_code& /*ec*/,
       std::size_t /*bytes_transferred*/)
   {
     // Take ownership of the handler object.
     reactive_socket_connect_op* o
       (static_cast<reactive_socket_connect_op*>(base));
-    ptr p = { boost::addressof(o->handler_), o, o };
+    ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
 
     BOOST_ASIO_HANDLER_COMPLETION((o));
 
     // Make a copy of the handler so that the memory can be deallocated before
     // the upcall is made. Even if we're not about to make an upcall, a
     // sub-object of the handler may be the true owner of the memory associated
     // with the handler. Consequently, a local copy of the handler is required
     // to ensure that any owning sub-object remains valid until after we have
     // deallocated the memory here.
     detail::binder1<Handler, boost::system::error_code>
       handler(o->handler_, o->ec_);
-    p.h = boost::addressof(handler.handler_);
+    p.h = boost::asio::detail::addressof(handler.handler_);
     p.reset();
 
     // Make the upcall if required.
     if (owner)
     {
       fenced_block b(fenced_block::half);
diff --git a/3rdParty/Boost/src/boost/asio/detail/reactive_socket_recv_op.hpp b/3rdParty/Boost/src/boost/asio/detail/reactive_socket_recv_op.hpp
index 8814c1e..d6a124d 100644
--- a/3rdParty/Boost/src/boost/asio/detail/reactive_socket_recv_op.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/reactive_socket_recv_op.hpp
@@ -1,11 +1,11 @@
 //
 // detail/reactive_socket_recv_op.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_REACTIVE_SOCKET_RECV_OP_HPP
@@ -13,13 +13,13 @@
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
-#include <boost/utility/addressof.hpp>
+#include <boost/asio/detail/addressof.hpp>
 #include <boost/asio/detail/bind_handler.hpp>
 #include <boost/asio/detail/buffer_sequence_adapter.hpp>
 #include <boost/asio/detail/fenced_block.hpp>
 #include <boost/asio/detail/reactor_op.hpp>
 #include <boost/asio/detail/socket_ops.hpp>
 
@@ -84,25 +84,25 @@ public:
   static void do_complete(io_service_impl* owner, operation* base,
       const boost::system::error_code& /*ec*/,
       std::size_t /*bytes_transferred*/)
   {
     // Take ownership of the handler object.
     reactive_socket_recv_op* o(static_cast<reactive_socket_recv_op*>(base));
-    ptr p = { boost::addressof(o->handler_), o, o };
+    ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
 
     BOOST_ASIO_HANDLER_COMPLETION((o));
 
     // Make a copy of the handler so that the memory can be deallocated before
     // the upcall is made. Even if we're not about to make an upcall, a
     // sub-object of the handler may be the true owner of the memory associated
     // with the handler. Consequently, a local copy of the handler is required
     // to ensure that any owning sub-object remains valid until after we have
     // deallocated the memory here.
     detail::binder2<Handler, boost::system::error_code, std::size_t>
       handler(o->handler_, o->ec_, o->bytes_transferred_);
-    p.h = boost::addressof(handler.handler_);
+    p.h = boost::asio::detail::addressof(handler.handler_);
     p.reset();
 
     // Make the upcall if required.
     if (owner)
     {
       fenced_block b(fenced_block::half);
diff --git a/3rdParty/Boost/src/boost/asio/detail/reactive_socket_recvfrom_op.hpp b/3rdParty/Boost/src/boost/asio/detail/reactive_socket_recvfrom_op.hpp
index a6b37e4..ef806bc 100644
--- a/3rdParty/Boost/src/boost/asio/detail/reactive_socket_recvfrom_op.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/reactive_socket_recvfrom_op.hpp
@@ -1,11 +1,11 @@
 //
 // detail/reactive_socket_recvfrom_op.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_REACTIVE_SOCKET_RECVFROM_OP_HPP
@@ -13,13 +13,13 @@
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
-#include <boost/utility/addressof.hpp>
+#include <boost/asio/detail/addressof.hpp>
 #include <boost/asio/detail/bind_handler.hpp>
 #include <boost/asio/detail/buffer_sequence_adapter.hpp>
 #include <boost/asio/detail/fenced_block.hpp>
 #include <boost/asio/detail/reactor_op.hpp>
 #include <boost/asio/detail/socket_ops.hpp>
 
@@ -94,25 +94,25 @@ public:
       const boost::system::error_code& /*ec*/,
       std::size_t /*bytes_transferred*/)
   {
     // Take ownership of the handler object.
     reactive_socket_recvfrom_op* o(
         static_cast<reactive_socket_recvfrom_op*>(base));
-    ptr p = { boost::addressof(o->handler_), o, o };
+    ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
 
     BOOST_ASIO_HANDLER_COMPLETION((o));
 
     // Make a copy of the handler so that the memory can be deallocated before
     // the upcall is made. Even if we're not about to make an upcall, a
     // sub-object of the handler may be the true owner of the memory associated
     // with the handler. Consequently, a local copy of the handler is required
     // to ensure that any owning sub-object remains valid until after we have
     // deallocated the memory here.
     detail::binder2<Handler, boost::system::error_code, std::size_t>
       handler(o->handler_, o->ec_, o->bytes_transferred_);
-    p.h = boost::addressof(handler.handler_);
+    p.h = boost::asio::detail::addressof(handler.handler_);
     p.reset();
 
     // Make the upcall if required.
     if (owner)
     {
       fenced_block b(fenced_block::half);
diff --git a/3rdParty/Boost/src/boost/asio/detail/reactive_socket_recvmsg_op.hpp b/3rdParty/Boost/src/boost/asio/detail/reactive_socket_recvmsg_op.hpp
index e9c2483..b6e0e3a 100644
--- a/3rdParty/Boost/src/boost/asio/detail/reactive_socket_recvmsg_op.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/reactive_socket_recvmsg_op.hpp
@@ -1,11 +1,11 @@
 //
 // detail/reactive_socket_recvmsg_op.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_REACTIVE_SOCKET_RECVMSG_OP_HPP
@@ -13,13 +13,13 @@
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
-#include <boost/utility/addressof.hpp>
+#include <boost/asio/detail/addressof.hpp>
 #include <boost/asio/detail/bind_handler.hpp>
 #include <boost/asio/detail/buffer_sequence_adapter.hpp>
 #include <boost/asio/detail/fenced_block.hpp>
 #include <boost/asio/detail/reactor_op.hpp>
 #include <boost/asio/detail/socket_ops.hpp>
 #include <boost/asio/socket_base.hpp>
@@ -86,25 +86,25 @@ public:
       const boost::system::error_code& /*ec*/,
       std::size_t /*bytes_transferred*/)
   {
     // Take ownership of the handler object.
     reactive_socket_recvmsg_op* o(
         static_cast<reactive_socket_recvmsg_op*>(base));
-    ptr p = { boost::addressof(o->handler_), o, o };
+    ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
 
     BOOST_ASIO_HANDLER_COMPLETION((o));
 
     // Make a copy of the handler so that the memory can be deallocated before
     // the upcall is made. Even if we're not about to make an upcall, a
     // sub-object of the handler may be the true owner of the memory associated
     // with the handler. Consequently, a local copy of the handler is required
     // to ensure that any owning sub-object remains valid until after we have
     // deallocated the memory here.
     detail::binder2<Handler, boost::system::error_code, std::size_t>
       handler(o->handler_, o->ec_, o->bytes_transferred_);
-    p.h = boost::addressof(handler.handler_);
+    p.h = boost::asio::detail::addressof(handler.handler_);
     p.reset();
 
     // Make the upcall if required.
     if (owner)
     {
       fenced_block b(fenced_block::half);
diff --git a/3rdParty/Boost/src/boost/asio/detail/reactive_socket_send_op.hpp b/3rdParty/Boost/src/boost/asio/detail/reactive_socket_send_op.hpp
index b1c3f65..a3a4424 100644
--- a/3rdParty/Boost/src/boost/asio/detail/reactive_socket_send_op.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/reactive_socket_send_op.hpp
@@ -1,11 +1,11 @@
 //
 // detail/reactive_socket_send_op.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_REACTIVE_SOCKET_SEND_OP_HPP
@@ -13,13 +13,13 @@
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
-#include <boost/utility/addressof.hpp>
+#include <boost/asio/detail/addressof.hpp>
 #include <boost/asio/detail/bind_handler.hpp>
 #include <boost/asio/detail/buffer_sequence_adapter.hpp>
 #include <boost/asio/detail/fenced_block.hpp>
 #include <boost/asio/detail/reactor_op.hpp>
 #include <boost/asio/detail/socket_ops.hpp>
 
@@ -81,25 +81,25 @@ public:
   static void do_complete(io_service_impl* owner, operation* base,
       const boost::system::error_code& /*ec*/,
       std::size_t /*bytes_transferred*/)
   {
     // Take ownership of the handler object.
     reactive_socket_send_op* o(static_cast<reactive_socket_send_op*>(base));
-    ptr p = { boost::addressof(o->handler_), o, o };
+    ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
 
     BOOST_ASIO_HANDLER_COMPLETION((o));
 
     // Make a copy of the handler so that the memory can be deallocated before
     // the upcall is made. Even if we're not about to make an upcall, a
     // sub-object of the handler may be the true owner of the memory associated
     // with the handler. Consequently, a local copy of the handler is required
     // to ensure that any owning sub-object remains valid until after we have
     // deallocated the memory here.
     detail::binder2<Handler, boost::system::error_code, std::size_t>
       handler(o->handler_, o->ec_, o->bytes_transferred_);
-    p.h = boost::addressof(handler.handler_);
+    p.h = boost::asio::detail::addressof(handler.handler_);
     p.reset();
 
     // Make the upcall if required.
     if (owner)
     {
       fenced_block b(fenced_block::half);
diff --git a/3rdParty/Boost/src/boost/asio/detail/reactive_socket_sendto_op.hpp b/3rdParty/Boost/src/boost/asio/detail/reactive_socket_sendto_op.hpp
index 08396a0..ffa1e68 100644
--- a/3rdParty/Boost/src/boost/asio/detail/reactive_socket_sendto_op.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/reactive_socket_sendto_op.hpp
@@ -1,11 +1,11 @@
 //
 // detail/reactive_socket_sendto_op.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_REACTIVE_SOCKET_SENDTO_OP_HPP
@@ -13,13 +13,13 @@
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
-#include <boost/utility/addressof.hpp>
+#include <boost/asio/detail/addressof.hpp>
 #include <boost/asio/detail/bind_handler.hpp>
 #include <boost/asio/detail/buffer_sequence_adapter.hpp>
 #include <boost/asio/detail/fenced_block.hpp>
 #include <boost/asio/detail/reactor_op.hpp>
 #include <boost/asio/detail/socket_ops.hpp>
 
@@ -84,25 +84,25 @@ public:
   static void do_complete(io_service_impl* owner, operation* base,
       const boost::system::error_code& /*ec*/,
       std::size_t /*bytes_transferred*/)
   {
     // Take ownership of the handler object.
     reactive_socket_sendto_op* o(static_cast<reactive_socket_sendto_op*>(base));
-    ptr p = { boost::addressof(o->handler_), o, o };
+    ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
 
     BOOST_ASIO_HANDLER_COMPLETION((o));
 
     // Make a copy of the handler so that the memory can be deallocated before
     // the upcall is made. Even if we're not about to make an upcall, a
     // sub-object of the handler may be the true owner of the memory associated
     // with the handler. Consequently, a local copy of the handler is required
     // to ensure that any owning sub-object remains valid until after we have
     // deallocated the memory here.
     detail::binder2<Handler, boost::system::error_code, std::size_t>
       handler(o->handler_, o->ec_, o->bytes_transferred_);
-    p.h = boost::addressof(handler.handler_);
+    p.h = boost::asio::detail::addressof(handler.handler_);
     p.reset();
 
     // Make the upcall if required.
     if (owner)
     {
       fenced_block b(fenced_block::half);
diff --git a/3rdParty/Boost/src/boost/asio/detail/reactive_socket_service.hpp b/3rdParty/Boost/src/boost/asio/detail/reactive_socket_service.hpp
index f66e25f..35678ae 100644
--- a/3rdParty/Boost/src/boost/asio/detail/reactive_socket_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/reactive_socket_service.hpp
@@ -1,11 +1,11 @@
 //
 // detail/reactive_socket_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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_REACTIVE_SOCKET_SERVICE_HPP
@@ -16,17 +16,17 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
 #if !defined(BOOST_ASIO_HAS_IOCP)
 
-#include <boost/utility/addressof.hpp>
 #include <boost/asio/buffer.hpp>
 #include <boost/asio/error.hpp>
 #include <boost/asio/io_service.hpp>
 #include <boost/asio/socket_base.hpp>
+#include <boost/asio/detail/addressof.hpp>
 #include <boost/asio/detail/buffer_sequence_adapter.hpp>
 #include <boost/asio/detail/noncopyable.hpp>
 #include <boost/asio/detail/reactive_null_buffers_op.hpp>
 #include <boost/asio/detail/reactive_socket_accept_op.hpp>
 #include <boost/asio/detail/reactive_socket_connect_op.hpp>
 #include <boost/asio/detail/reactive_socket_recvfrom_op.hpp>
@@ -96,12 +96,24 @@ public:
     this->base_move_assign(impl, other_service, other_impl);
 
     impl.protocol_ = other_impl.protocol_;
     other_impl.protocol_ = endpoint_type().protocol();
   }
 
+  // Move-construct a new socket implementation from another protocol type.
+  template <typename Protocol1>
+  void converting_move_construct(implementation_type& impl,
+      typename reactive_socket_service<
+        Protocol1>::implementation_type& other_impl)
+  {
+    this->base_move_construct(impl, other_impl);
+
+    impl.protocol_ = protocol_type(other_impl.protocol_);
+    other_impl.protocol_ = typename Protocol1::endpoint().protocol();
+  }
+
   // Open a new socket implementation.
   boost::system::error_code open(implementation_type& impl,
       const protocol_type& protocol, boost::system::error_code& ec)
   {
     if (!do_open(impl, protocol.family(),
           protocol.type(), protocol.protocol(), ec))
@@ -212,44 +224,50 @@ public:
   // Start an asynchronous send. The data being sent must be valid for the
   // lifetime of the asynchronous operation.
   template <typename ConstBufferSequence, typename Handler>
   void async_send_to(implementation_type& impl,
       const ConstBufferSequence& buffers,
       const endpoint_type& destination, socket_base::message_flags flags,
-      Handler handler)
+      Handler& handler)
   {
+    bool is_continuation =
+      boost_asio_handler_cont_helpers::is_continuation(handler);
+
     // Allocate and construct an operation to wrap the handler.
     typedef reactive_socket_sendto_op<ConstBufferSequence,
         endpoint_type, Handler> op;
-    typename op::ptr p = { boost::addressof(handler),
+    typename op::ptr p = { boost::asio::detail::addressof(handler),
       boost_asio_handler_alloc_helpers::allocate(
         sizeof(op), handler), 0 };
     p.p = new (p.v) op(impl.socket_, buffers, destination, flags, handler);
 
     BOOST_ASIO_HANDLER_CREATION((p.p, "socket", &impl, "async_send_to"));
 
-    start_op(impl, reactor::write_op, p.p, true, false);
+    start_op(impl, reactor::write_op, p.p, is_continuation, true, false);
     p.v = p.p = 0;
   }
 
   // Start an asynchronous wait until data can be sent without blocking.
   template <typename Handler>
   void async_send_to(implementation_type& impl, const null_buffers&,
-      const endpoint_type&, socket_base::message_flags, Handler handler)
+      const endpoint_type&, socket_base::message_flags, Handler& handler)
   {
+    bool is_continuation =
+      boost_asio_handler_cont_helpers::is_continuation(handler);
+
     // Allocate and construct an operation to wrap the handler.
     typedef reactive_null_buffers_op<Handler> op;
-    typename op::ptr p = { boost::addressof(handler),
+    typename op::ptr p = { boost::asio::detail::addressof(handler),
       boost_asio_handler_alloc_helpers::allocate(
         sizeof(op), handler), 0 };
     p.p = new (p.v) op(handler);
 
     BOOST_ASIO_HANDLER_CREATION((p.p, "socket",
           &impl, "async_send_to(null_buffers)"));
 
-    start_op(impl, reactor::write_op, p.p, false, false);
+    start_op(impl, reactor::write_op, p.p, is_continuation, false, false);
     p.v = p.p = 0;
   }
 
   // Receive a datagram with the endpoint of the sender. Returns the number of
   // bytes received.
   template <typename MutableBufferSequence>
@@ -289,43 +307,49 @@ public:
   // Start an asynchronous receive. The buffer for the data being received and
   // the sender_endpoint object must both be valid for the lifetime of the
   // asynchronous operation.
   template <typename MutableBufferSequence, typename Handler>
   void async_receive_from(implementation_type& impl,
       const MutableBufferSequence& buffers, endpoint_type& sender_endpoint,
-      socket_base::message_flags flags, Handler handler)
+      socket_base::message_flags flags, Handler& handler)
   {
+    bool is_continuation =
+      boost_asio_handler_cont_helpers::is_continuation(handler);
+
     // Allocate and construct an operation to wrap the handler.
     typedef reactive_socket_recvfrom_op<MutableBufferSequence,
         endpoint_type, Handler> op;
-    typename op::ptr p = { boost::addressof(handler),
+    typename op::ptr p = { boost::asio::detail::addressof(handler),
       boost_asio_handler_alloc_helpers::allocate(
         sizeof(op), handler), 0 };
     int protocol = impl.protocol_.type();
     p.p = new (p.v) op(impl.socket_, protocol,
         buffers, sender_endpoint, flags, handler);
 
     BOOST_ASIO_HANDLER_CREATION((p.p, "socket",
           &impl, "async_receive_from"));
 
     start_op(impl,
         (flags & socket_base::message_out_of_band)
           ? reactor::except_op : reactor::read_op,
-        p.p, true, false);
+        p.p, is_continuation, true, false);
     p.v = p.p = 0;
   }
 
   // Wait until data can be received without blocking.
   template <typename Handler>
   void async_receive_from(implementation_type& impl,
       const null_buffers&, endpoint_type& sender_endpoint,
-      socket_base::message_flags flags, Handler handler)
+      socket_base::message_flags flags, Handler& handler)
   {
+    bool is_continuation =
+      boost_asio_handler_cont_helpers::is_continuation(handler);
+
     // Allocate and construct an operation to wrap the handler.
     typedef reactive_null_buffers_op<Handler> op;
-    typename op::ptr p = { boost::addressof(handler),
+    typename op::ptr p = { boost::asio::detail::addressof(handler),
       boost_asio_handler_alloc_helpers::allocate(
         sizeof(op), handler), 0 };
     p.p = new (p.v) op(handler);
 
     BOOST_ASIO_HANDLER_CREATION((p.p, "socket",
           &impl, "async_receive_from(null_buffers)"));
@@ -333,13 +357,13 @@ public:
     // Reset endpoint since it can be given no sensible value at this time.
     sender_endpoint = endpoint_type();
 
     start_op(impl,
         (flags & socket_base::message_out_of_band)
           ? reactor::except_op : reactor::read_op,
-        p.p, false, false);
+        p.p, is_continuation, false, false);
     p.v = p.p = 0;
   }
 
   // Accept a new connection.
   template <typename Socket>
   boost::system::error_code accept(implementation_type& impl,
@@ -370,25 +394,28 @@ public:
   }
 
   // Start an asynchronous accept. The peer and peer_endpoint objects
   // must be valid until the accept's handler is invoked.
   template <typename Socket, typename Handler>
   void async_accept(implementation_type& impl, Socket& peer,
-      endpoint_type* peer_endpoint, Handler handler)
+      endpoint_type* peer_endpoint, Handler& handler)
   {
+    bool is_continuation =
+      boost_asio_handler_cont_helpers::is_continuation(handler);
+
     // Allocate and construct an operation to wrap the handler.
     typedef reactive_socket_accept_op<Socket, Protocol, Handler> op;
-    typename op::ptr p = { boost::addressof(handler),
+    typename op::ptr p = { boost::asio::detail::addressof(handler),
       boost_asio_handler_alloc_helpers::allocate(
         sizeof(op), handler), 0 };
     p.p = new (p.v) op(impl.socket_, impl.state_, peer,
         impl.protocol_, peer_endpoint, handler);
 
     BOOST_ASIO_HANDLER_CREATION((p.p, "socket", &impl, "async_accept"));
 
-    start_accept_op(impl, p.p, peer.is_open());
+    start_accept_op(impl, p.p, is_continuation, peer.is_open());
     p.v = p.p = 0;
   }
 
   // Connect the socket to the specified endpoint.
   boost::system::error_code connect(implementation_type& impl,
       const endpoint_type& peer_endpoint, boost::system::error_code& ec)
@@ -398,24 +425,28 @@ public:
     return ec;
   }
 
   // Start an asynchronous connect.
   template <typename Handler>
   void async_connect(implementation_type& impl,
-      const endpoint_type& peer_endpoint, Handler handler)
+      const endpoint_type& peer_endpoint, Handler& handler)
   {
+    bool is_continuation =
+      boost_asio_handler_cont_helpers::is_continuation(handler);
+
     // Allocate and construct an operation to wrap the handler.
     typedef reactive_socket_connect_op<Handler> op;
-    typename op::ptr p = { boost::addressof(handler),
+    typename op::ptr p = { boost::asio::detail::addressof(handler),
       boost_asio_handler_alloc_helpers::allocate(
         sizeof(op), handler), 0 };
     p.p = new (p.v) op(impl.socket_, handler);
 
     BOOST_ASIO_HANDLER_CREATION((p.p, "socket", &impl, "async_connect"));
 
-    start_connect_op(impl, p.p, peer_endpoint.data(), peer_endpoint.size());
+    start_connect_op(impl, p.p, is_continuation,
+        peer_endpoint.data(), peer_endpoint.size());
     p.v = p.p = 0;
   }
 };
 
 } // namespace detail
 } // namespace asio
diff --git a/3rdParty/Boost/src/boost/asio/detail/reactive_socket_service_base.hpp b/3rdParty/Boost/src/boost/asio/detail/reactive_socket_service_base.hpp
index 0180435..aeaf4f4 100644
--- a/3rdParty/Boost/src/boost/asio/detail/reactive_socket_service_base.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/reactive_socket_service_base.hpp
@@ -1,11 +1,11 @@
 //
 // detail/reactive_socket_service_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)
 //
 // 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_DETAIL_REACTIVE_SOCKET_SERVICE_BASE_HPP
@@ -14,19 +14,20 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
-#if !defined(BOOST_ASIO_HAS_IOCP)
+#if !defined(BOOST_ASIO_HAS_IOCP) \
+  && !defined(BOOST_ASIO_WINDOWS_RUNTIME)
 
-#include <boost/utility/addressof.hpp>
 #include <boost/asio/buffer.hpp>
 #include <boost/asio/error.hpp>
 #include <boost/asio/io_service.hpp>
 #include <boost/asio/socket_base.hpp>
+#include <boost/asio/detail/addressof.hpp>
 #include <boost/asio/detail/buffer_sequence_adapter.hpp>
 #include <boost/asio/detail/reactive_null_buffers_op.hpp>
 #include <boost/asio/detail/reactive_socket_recv_op.hpp>
 #include <boost/asio/detail/reactive_socket_recvmsg_op.hpp>
 #include <boost/asio/detail/reactive_socket_send_op.hpp>
 #include <boost/asio/detail/reactor.hpp>
@@ -195,46 +196,52 @@ public:
 
   // Start an asynchronous send. The data being sent must be valid for the
   // lifetime of the asynchronous operation.
   template <typename ConstBufferSequence, typename Handler>
   void async_send(base_implementation_type& impl,
       const ConstBufferSequence& buffers,
-      socket_base::message_flags flags, Handler handler)
+      socket_base::message_flags flags, Handler& handler)
   {
+    bool is_continuation =
+      boost_asio_handler_cont_helpers::is_continuation(handler);
+
     // Allocate and construct an operation to wrap the handler.
     typedef reactive_socket_send_op<ConstBufferSequence, Handler> op;
-    typename op::ptr p = { boost::addressof(handler),
+    typename op::ptr p = { boost::asio::detail::addressof(handler),
       boost_asio_handler_alloc_helpers::allocate(
         sizeof(op), handler), 0 };
     p.p = new (p.v) op(impl.socket_, buffers, flags, handler);
 
     BOOST_ASIO_HANDLER_CREATION((p.p, "socket", &impl, "async_send"));
 
-    start_op(impl, reactor::write_op, p.p, true,
+    start_op(impl, reactor::write_op, p.p, is_continuation, true,
         ((impl.state_ & socket_ops::stream_oriented)
           && buffer_sequence_adapter<boost::asio::const_buffer,
             ConstBufferSequence>::all_empty(buffers)));
     p.v = p.p = 0;
   }
 
   // Start an asynchronous wait until data can be sent without blocking.
   template <typename Handler>
   void async_send(base_implementation_type& impl, const null_buffers&,
-      socket_base::message_flags, Handler handler)
+      socket_base::message_flags, Handler& handler)
   {
+    bool is_continuation =
+      boost_asio_handler_cont_helpers::is_continuation(handler);
+
     // Allocate and construct an operation to wrap the handler.
     typedef reactive_null_buffers_op<Handler> op;
-    typename op::ptr p = { boost::addressof(handler),
+    typename op::ptr p = { boost::asio::detail::addressof(handler),
       boost_asio_handler_alloc_helpers::allocate(
         sizeof(op), handler), 0 };
     p.p = new (p.v) op(handler);
 
     BOOST_ASIO_HANDLER_CREATION((p.p, "socket",
           &impl, "async_send(null_buffers)"));
 
-    start_op(impl, reactor::write_op, p.p, false, false);
+    start_op(impl, reactor::write_op, p.p, is_continuation, false, false);
     p.v = p.p = 0;
   }
 
   // Receive some data from the peer. Returns the number of bytes received.
   template <typename MutableBufferSequence>
   size_t receive(base_implementation_type& impl,
@@ -260,52 +267,59 @@ public:
 
   // Start an asynchronous receive. The buffer for the data being received
   // must be valid for the lifetime of the asynchronous operation.
   template <typename MutableBufferSequence, typename Handler>
   void async_receive(base_implementation_type& impl,
       const MutableBufferSequence& buffers,
-      socket_base::message_flags flags, Handler handler)
+      socket_base::message_flags flags, Handler& handler)
   {
+    bool is_continuation =
+      boost_asio_handler_cont_helpers::is_continuation(handler);
+
     // Allocate and construct an operation to wrap the handler.
     typedef reactive_socket_recv_op<MutableBufferSequence, Handler> op;
-    typename op::ptr p = { boost::addressof(handler),
+    typename op::ptr p = { boost::asio::detail::addressof(handler),
       boost_asio_handler_alloc_helpers::allocate(
         sizeof(op), handler), 0 };
     p.p = new (p.v) op(impl.socket_, impl.state_, buffers, flags, handler);
 
     BOOST_ASIO_HANDLER_CREATION((p.p, "socket", &impl, "async_receive"));
 
     start_op(impl,
         (flags & socket_base::message_out_of_band)
           ? reactor::except_op : reactor::read_op,
-        p.p, (flags & socket_base::message_out_of_band) == 0,
+        p.p, is_continuation,
+        (flags & socket_base::message_out_of_band) == 0,
         ((impl.state_ & socket_ops::stream_oriented)
           && buffer_sequence_adapter<boost::asio::mutable_buffer,
             MutableBufferSequence>::all_empty(buffers)));
     p.v = p.p = 0;
   }
 
   // Wait until data can be received without blocking.
   template <typename Handler>
   void async_receive(base_implementation_type& impl, const null_buffers&,
-      socket_base::message_flags flags, Handler handler)
+      socket_base::message_flags flags, Handler& handler)
   {
+    bool is_continuation =
+      boost_asio_handler_cont_helpers::is_continuation(handler);
+
     // Allocate and construct an operation to wrap the handler.
     typedef reactive_null_buffers_op<Handler> op;
-    typename op::ptr p = { boost::addressof(handler),
+    typename op::ptr p = { boost::asio::detail::addressof(handler),
       boost_asio_handler_alloc_helpers::allocate(
         sizeof(op), handler), 0 };
     p.p = new (p.v) op(handler);
 
     BOOST_ASIO_HANDLER_CREATION((p.p, "socket",
           &impl, "async_receive(null_buffers)"));
 
     start_op(impl,
         (flags & socket_base::message_out_of_band)
           ? reactor::except_op : reactor::read_op,
-        p.p, false, false);
+        p.p, is_continuation, false, false);
     p.v = p.p = 0;
   }
 
   // Receive some data with associated flags. Returns the number of bytes
   // received.
   template <typename MutableBufferSequence>
@@ -338,40 +352,47 @@ public:
 
   // Start an asynchronous receive. The buffer for the data being received
   // must be valid for the lifetime of the asynchronous operation.
   template <typename MutableBufferSequence, typename Handler>
   void async_receive_with_flags(base_implementation_type& impl,
       const MutableBufferSequence& buffers, socket_base::message_flags in_flags,
-      socket_base::message_flags& out_flags, Handler handler)
+      socket_base::message_flags& out_flags, Handler& handler)
   {
+    bool is_continuation =
+      boost_asio_handler_cont_helpers::is_continuation(handler);
+
     // Allocate and construct an operation to wrap the handler.
     typedef reactive_socket_recvmsg_op<MutableBufferSequence, Handler> op;
-    typename op::ptr p = { boost::addressof(handler),
+    typename op::ptr p = { boost::asio::detail::addressof(handler),
       boost_asio_handler_alloc_helpers::allocate(
         sizeof(op), handler), 0 };
     p.p = new (p.v) op(impl.socket_, buffers, in_flags, out_flags, handler);
 
     BOOST_ASIO_HANDLER_CREATION((p.p, "socket",
           &impl, "async_receive_with_flags"));
 
     start_op(impl,
         (in_flags & socket_base::message_out_of_band)
           ? reactor::except_op : reactor::read_op,
-        p.p, (in_flags & socket_base::message_out_of_band) == 0, false);
+        p.p, is_continuation,
+        (in_flags & socket_base::message_out_of_band) == 0, false);
     p.v = p.p = 0;
   }
 
   // Wait until data can be received without blocking.
   template <typename Handler>
   void async_receive_with_flags(base_implementation_type& impl,
       const null_buffers&, socket_base::message_flags in_flags,
-      socket_base::message_flags& out_flags, Handler handler)
+      socket_base::message_flags& out_flags, Handler& handler)
   {
+    bool is_continuation =
+      boost_asio_handler_cont_helpers::is_continuation(handler);
+
     // Allocate and construct an operation to wrap the handler.
     typedef reactive_null_buffers_op<Handler> op;
-    typename op::ptr p = { boost::addressof(handler),
+    typename op::ptr p = { boost::asio::detail::addressof(handler),
       boost_asio_handler_alloc_helpers::allocate(
         sizeof(op), handler), 0 };
     p.p = new (p.v) op(handler);
 
     BOOST_ASIO_HANDLER_CREATION((p.p, "socket", &impl,
           "async_receive_with_flags(null_buffers)"));
@@ -380,13 +401,13 @@ public:
     // performing a null_buffers operation.
     out_flags = 0;
 
     start_op(impl,
         (in_flags & socket_base::message_out_of_band)
           ? reactor::except_op : reactor::read_op,
-        p.p, false, false);
+        p.p, is_continuation, false, false);
     p.v = p.p = 0;
   }
 
 protected:
   // Open a new socket implementation.
   BOOST_ASIO_DECL boost::system::error_code do_open(
@@ -397,21 +418,22 @@ protected:
   BOOST_ASIO_DECL boost::system::error_code do_assign(
       base_implementation_type& impl, int type,
       const native_handle_type& native_socket, boost::system::error_code& ec);
 
   // Start the asynchronous read or write operation.
   BOOST_ASIO_DECL void start_op(base_implementation_type& impl, int op_type,
-      reactor_op* op, bool is_non_blocking, bool noop);
+      reactor_op* op, bool is_continuation, bool is_non_blocking, bool noop);
 
   // Start the asynchronous accept operation.
   BOOST_ASIO_DECL void start_accept_op(base_implementation_type& impl,
-      reactor_op* op, bool peer_is_open);
+      reactor_op* op, bool is_continuation, bool peer_is_open);
 
   // Start the asynchronous connect operation.
   BOOST_ASIO_DECL void start_connect_op(base_implementation_type& impl,
-      reactor_op* op, const socket_addr_type* addr, size_t addrlen);
+      reactor_op* op, bool is_continuation,
+      const socket_addr_type* addr, size_t addrlen);
 
   // The selector that performs event demultiplexing for the service.
   reactor& reactor_;
 };
 
 } // namespace detail
@@ -422,8 +444,9 @@ protected:
 
 #if defined(BOOST_ASIO_HEADER_ONLY)
 # include <boost/asio/detail/impl/reactive_socket_service_base.ipp>
 #endif // defined(BOOST_ASIO_HEADER_ONLY)
 
 #endif // !defined(BOOST_ASIO_HAS_IOCP)
+       //   && !defined(BOOST_ASIO_WINDOWS_RUNTIME)
 
 #endif // BOOST_ASIO_DETAIL_REACTIVE_SOCKET_SERVICE_BASE_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/reactor.hpp b/3rdParty/Boost/src/boost/asio/detail/reactor.hpp
index 7e28679..e183793 100644
--- a/3rdParty/Boost/src/boost/asio/detail/reactor.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/reactor.hpp
@@ -1,11 +1,11 @@
 //
 // detail/reactor.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_REACTOR_HPP
@@ -20,11 +20,13 @@
 #if defined(BOOST_ASIO_HAS_EPOLL)
 # include <boost/asio/detail/epoll_reactor.hpp>
 #elif defined(BOOST_ASIO_HAS_KQUEUE)
 # include <boost/asio/detail/kqueue_reactor.hpp>
 #elif defined(BOOST_ASIO_HAS_DEV_POLL)
 # include <boost/asio/detail/dev_poll_reactor.hpp>
+#elif defined(BOOST_ASIO_WINDOWS_RUNTIME)
+# include <boost/asio/detail/null_reactor.hpp>
 #else
 # include <boost/asio/detail/select_reactor.hpp>
 #endif
 
 #endif // BOOST_ASIO_DETAIL_REACTOR_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/reactor_fwd.hpp b/3rdParty/Boost/src/boost/asio/detail/reactor_fwd.hpp
index 7ea119e..80f4032 100644
--- a/3rdParty/Boost/src/boost/asio/detail/reactor_fwd.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/reactor_fwd.hpp
@@ -1,11 +1,11 @@
 //
 // detail/reactor_fwd.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_REACTOR_FWD_HPP
@@ -14,38 +14,28 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
-#if defined(BOOST_ASIO_HAS_IOCP)
-# include <boost/asio/detail/select_reactor_fwd.hpp>
-#elif defined(BOOST_ASIO_HAS_EPOLL)
-# include <boost/asio/detail/epoll_reactor_fwd.hpp>
-#elif defined(BOOST_ASIO_HAS_KQUEUE)
-# include <boost/asio/detail/kqueue_reactor_fwd.hpp>
-#elif defined(BOOST_ASIO_HAS_DEV_POLL)
-# include <boost/asio/detail/dev_poll_reactor_fwd.hpp>
-#else
-# include <boost/asio/detail/select_reactor_fwd.hpp>
-#endif
-
 namespace boost {
 namespace asio {
 namespace detail {
 
-#if defined(BOOST_ASIO_HAS_IOCP)
-typedef select_reactor reactor;
+#if defined(BOOST_ASIO_WINDOWS_RUNTIME)
+typedef class null_reactor reactor;
+#elif defined(BOOST_ASIO_HAS_IOCP)
+typedef class select_reactor reactor;
 #elif defined(BOOST_ASIO_HAS_EPOLL)
-typedef epoll_reactor reactor;
+typedef class epoll_reactor reactor;
 #elif defined(BOOST_ASIO_HAS_KQUEUE)
-typedef kqueue_reactor reactor;
+typedef class kqueue_reactor reactor;
 #elif defined(BOOST_ASIO_HAS_DEV_POLL)
-typedef dev_poll_reactor reactor;
+typedef class dev_poll_reactor reactor;
 #else
-typedef select_reactor reactor;
+typedef class select_reactor reactor;
 #endif
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
diff --git a/3rdParty/Boost/src/boost/asio/detail/reactor_op.hpp b/3rdParty/Boost/src/boost/asio/detail/reactor_op.hpp
index 3b8e7f9..959badd 100644
--- a/3rdParty/Boost/src/boost/asio/detail/reactor_op.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/reactor_op.hpp
@@ -1,11 +1,11 @@
 //
 // detail/reactor_op.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_REACTOR_OP_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/reactor_op_queue.hpp b/3rdParty/Boost/src/boost/asio/detail/reactor_op_queue.hpp
index 692a2ee..effe771 100644
--- a/3rdParty/Boost/src/boost/asio/detail/reactor_op_queue.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/reactor_op_queue.hpp
@@ -1,11 +1,11 @@
 //
 // detail/reactor_op_queue.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_REACTOR_OP_QUEUE_HPP
@@ -30,170 +30,138 @@ namespace detail {
 
 template <typename Descriptor>
 class reactor_op_queue
   : private noncopyable
 {
 public:
+  typedef Descriptor key_type;
+
+  struct mapped_type : op_queue<reactor_op>
+  {
+    mapped_type() {}
+    mapped_type(const mapped_type&) {}
+    void operator=(const mapped_type&) {}
+  };
+
+  typedef typename hash_map<key_type, mapped_type>::value_type value_type;
+  typedef typename hash_map<key_type, mapped_type>::iterator iterator;
+
   // Constructor.
   reactor_op_queue()
     : operations_()
   {
   }
 
+  // Obtain iterators to all registered descriptors.
+  iterator begin() { return operations_.begin(); }
+  iterator end() { return operations_.end(); }
+
   // Add a new operation to the queue. Returns true if this is the only
   // operation for the given descriptor, in which case the reactor's event
   // demultiplexing function call may need to be interrupted and restarted.
   bool enqueue_operation(Descriptor descriptor, reactor_op* op)
   {
-    typedef typename operations_map::iterator iterator;
-    typedef typename operations_map::value_type value_type;
     std::pair<iterator, bool> entry =
-      operations_.insert(value_type(descriptor, operations()));
-    entry.first->second.op_queue_.push(op);
+      operations_.insert(value_type(descriptor, mapped_type()));
+    entry.first->second.push(op);
     return entry.second;
   }
 
-  // Cancel all operations associated with the descriptor. Any operations
-  // pending for the descriptor will be notified that they have been cancelled
-  // next time perform_cancellations is called. Returns true if any operations
-  // were cancelled, in which case the reactor's event demultiplexing function
-  // may need to be interrupted and restarted.
-  bool cancel_operations(Descriptor descriptor, op_queue<operation>& ops,
+  // Cancel all operations associated with the descriptor identified by the
+  // supplied iterator. Any operations pending for the descriptor will be
+  // cancelled. Returns true if any operations were cancelled, in which case
+  // the reactor's event demultiplexing function may need to be interrupted and
+  // restarted.
+  bool cancel_operations(iterator i, op_queue<operation>& ops,
       const boost::system::error_code& ec =
         boost::asio::error::operation_aborted)
   {
-    typename operations_map::iterator i = operations_.find(descriptor);
     if (i != operations_.end())
     {
-      while (reactor_op* op = i->second.op_queue_.front())
+      while (reactor_op* op = i->second.front())
       {
         op->ec_ = ec;
-        i->second.op_queue_.pop();
+        i->second.pop();
         ops.push(op);
       }
       operations_.erase(i);
       return true;
     }
 
     return false;
   }
 
+  // Cancel all operations associated with the descriptor. Any operations
+  // pending for the descriptor will be cancelled. Returns true if any
+  // operations were cancelled, in which case the reactor's event
+  // demultiplexing function may need to be interrupted and restarted.
+  bool cancel_operations(Descriptor descriptor, op_queue<operation>& ops,
+      const boost::system::error_code& ec =
+        boost::asio::error::operation_aborted)
+  {
+    return this->cancel_operations(operations_.find(descriptor), ops, ec);
+  }
+
   // Whether there are no operations in the queue.
   bool empty() const
   {
     return operations_.empty();
   }
 
   // Determine whether there are any operations associated with the descriptor.
   bool has_operation(Descriptor descriptor) const
   {
     return operations_.find(descriptor) != operations_.end();
   }
 
-  // Perform the operations corresponding to the descriptor. Returns true if
-  // there are still unfinished operations queued for the descriptor.
-  bool perform_operations(Descriptor descriptor, op_queue<operation>& ops)
+  // Perform the operations corresponding to the descriptor identified by the
+  // supplied iterator. Returns true if there are still unfinished operations
+  // queued for the descriptor.
+  bool perform_operations(iterator i, op_queue<operation>& ops)
   {
-    typename operations_map::iterator i = operations_.find(descriptor);
     if (i != operations_.end())
     {
-      while (reactor_op* op = i->second.op_queue_.front())
+      while (reactor_op* op = i->second.front())
       {
         if (op->perform())
         {
-          i->second.op_queue_.pop();
+          i->second.pop();
           ops.push(op);
         }
         else
         {
           return true;
         }
       }
       operations_.erase(i);
     }
     return false;
   }
 
-  // Fill a descriptor set with the descriptors corresponding to each active
-  // operation. The op_queue is used only when descriptors fail to be added to
-  // the descriptor set.
-  template <typename Descriptor_Set>
-  void get_descriptors(Descriptor_Set& descriptors, op_queue<operation>& ops)
-  {
-    typename operations_map::iterator i = operations_.begin();
-    while (i != operations_.end())
-    {
-      Descriptor descriptor = i->first;
-      ++i;
-      if (!descriptors.set(descriptor))
-      {
-        boost::system::error_code ec(error::fd_set_failure);
-        cancel_operations(descriptor, ops, ec);
-      }
-    }
-  }
-
-  // Perform the operations corresponding to the ready file descriptors
-  // contained in the given descriptor set.
-  template <typename Descriptor_Set>
-  void perform_operations_for_descriptors(
-      const Descriptor_Set& descriptors, op_queue<operation>& ops)
+  // Perform the operations corresponding to the descriptor. Returns true if
+  // there are still unfinished operations queued for the descriptor.
+  bool perform_operations(Descriptor descriptor, op_queue<operation>& ops)
   {
-    typename operations_map::iterator i = operations_.begin();
-    while (i != operations_.end())
-    {
-      typename operations_map::iterator op_iter = i++;
-      if (descriptors.is_set(op_iter->first))
-      {
-        while (reactor_op* op = op_iter->second.op_queue_.front())
-        {
-          if (op->perform())
-          {
-            op_iter->second.op_queue_.pop();
-            ops.push(op);
-          }
-          else
-          {
-            break;
-          }
-        }
-
-        if (op_iter->second.op_queue_.empty())
-          operations_.erase(op_iter);
-      }
-    }
+    return this->perform_operations(operations_.find(descriptor), ops);
   }
 
   // Get all operations owned by the queue.
   void get_all_operations(op_queue<operation>& ops)
   {
-    typename operations_map::iterator i = operations_.begin();
+    iterator i = operations_.begin();
     while (i != operations_.end())
     {
-      typename operations_map::iterator op_iter = i++;
-      ops.push(op_iter->second.op_queue_);
+      iterator op_iter = i++;
+      ops.push(op_iter->second);
       operations_.erase(op_iter);
     }
   }
 
 private:
-  struct operations
-  {
-    operations() {}
-    operations(const operations&) {}
-    void operator=(const operations&) {}
-
-    // The operations waiting on the desccriptor.
-    op_queue<reactor_op> op_queue_;
-  };
-
-  // The type for a map of operations.
-  typedef hash_map<Descriptor, operations> operations_map;
-
   // The operations that are currently executing asynchronously.
-  operations_map operations_;
+  hash_map<key_type, mapped_type> operations_;
 };
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
diff --git a/3rdParty/Boost/src/boost/asio/detail/regex_fwd.hpp b/3rdParty/Boost/src/boost/asio/detail/regex_fwd.hpp
index 679146e..2b23b59 100644
--- a/3rdParty/Boost/src/boost/asio/detail/regex_fwd.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/regex_fwd.hpp
@@ -1,23 +1,25 @@
 //
 // detail/regex_fwd.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_REGEX_FWD_HPP
 #define BOOST_ASIO_DETAIL_REGEX_FWD_HPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
+#if defined(BOOST_ASIO_HAS_BOOST_REGEX)
+
 #include <boost/regex_fwd.hpp>
 #include <boost/regex/v4/match_flags.hpp>
 
 namespace boost {
 
 template <class BidiIterator>
@@ -25,7 +27,9 @@ struct sub_match;
 
 template <class BidiIterator, class Allocator>
 class match_results;
 
 } // namespace boost
 
+#endif // defined(BOOST_ASIO_HAS_BOOST_REGEX)
+
 #endif // BOOST_ASIO_DETAIL_REGEX_FWD_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/resolve_endpoint_op.hpp b/3rdParty/Boost/src/boost/asio/detail/resolve_endpoint_op.hpp
index e6c901a..28119bb 100644
--- a/3rdParty/Boost/src/boost/asio/detail/resolve_endpoint_op.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/resolve_endpoint_op.hpp
@@ -1,11 +1,11 @@
 //
 // detail/resolve_endpoint_op.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_RESOLVER_ENDPOINT_OP_HPP
@@ -13,16 +13,16 @@
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
-#include <boost/utility/addressof.hpp>
 #include <boost/asio/error.hpp>
 #include <boost/asio/io_service.hpp>
 #include <boost/asio/ip/basic_resolver_iterator.hpp>
+#include <boost/asio/detail/addressof.hpp>
 #include <boost/asio/detail/bind_handler.hpp>
 #include <boost/asio/detail/fenced_block.hpp>
 #include <boost/asio/detail/handler_alloc_helpers.hpp>
 #include <boost/asio/detail/handler_invoke_helpers.hpp>
 #include <boost/asio/detail/operation.hpp>
 #include <boost/asio/detail/socket_ops.hpp>
@@ -55,13 +55,13 @@ public:
   static void do_complete(io_service_impl* owner, operation* base,
       const boost::system::error_code& /*ec*/,
       std::size_t /*bytes_transferred*/)
   {
     // Take ownership of the operation object.
     resolve_endpoint_op* o(static_cast<resolve_endpoint_op*>(base));
-    ptr p = { boost::addressof(o->handler_), o, o };
+    ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
 
     if (owner && owner != &o->io_service_impl_)
     {
       // The operation is being run on the worker io_service. Time to perform
       // the resolver operation.
     
@@ -89,13 +89,13 @@ public:
       // a sub-object of the handler may be the true owner of the memory
       // associated with the handler. Consequently, a local copy of the handler
       // is required to ensure that any owning sub-object remains valid until
       // after we have deallocated the memory here.
       detail::binder2<Handler, boost::system::error_code, iterator_type>
         handler(o->handler_, o->ec_, o->iter_);
-      p.h = boost::addressof(handler.handler_);
+      p.h = boost::asio::detail::addressof(handler.handler_);
       p.reset();
 
       if (owner)
       {
         fenced_block b(fenced_block::half);
         BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, "..."));
diff --git a/3rdParty/Boost/src/boost/asio/detail/resolve_op.hpp b/3rdParty/Boost/src/boost/asio/detail/resolve_op.hpp
index b640979..bed1c3c 100644
--- a/3rdParty/Boost/src/boost/asio/detail/resolve_op.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/resolve_op.hpp
@@ -1,11 +1,11 @@
 //
 // detail/resolve_op.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_RESOLVE_OP_HPP
@@ -13,17 +13,17 @@
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
-#include <boost/utility/addressof.hpp>
 #include <boost/asio/error.hpp>
 #include <boost/asio/io_service.hpp>
 #include <boost/asio/ip/basic_resolver_iterator.hpp>
 #include <boost/asio/ip/basic_resolver_query.hpp>
+#include <boost/asio/detail/addressof.hpp>
 #include <boost/asio/detail/bind_handler.hpp>
 #include <boost/asio/detail/fenced_block.hpp>
 #include <boost/asio/detail/handler_alloc_helpers.hpp>
 #include <boost/asio/detail/handler_invoke_helpers.hpp>
 #include <boost/asio/detail/operation.hpp>
 #include <boost/asio/detail/socket_ops.hpp>
@@ -63,13 +63,13 @@ public:
   static void do_complete(io_service_impl* owner, operation* base,
       const boost::system::error_code& /*ec*/,
       std::size_t /*bytes_transferred*/)
   {
     // Take ownership of the operation object.
     resolve_op* o(static_cast<resolve_op*>(base));
-    ptr p = { boost::addressof(o->handler_), o, o };
+    ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
 
     if (owner && owner != &o->io_service_impl_)
     {
       // The operation is being run on the worker io_service. Time to perform
       // the resolver operation.
     
@@ -94,13 +94,13 @@ public:
       // a sub-object of the handler may be the true owner of the memory
       // associated with the handler. Consequently, a local copy of the handler
       // is required to ensure that any owning sub-object remains valid until
       // after we have deallocated the memory here.
       detail::binder2<Handler, boost::system::error_code, iterator_type>
         handler(o->handler_, o->ec_, iterator_type());
-      p.h = boost::addressof(handler.handler_);
+      p.h = boost::asio::detail::addressof(handler.handler_);
       if (o->addrinfo_)
       {
         handler.arg2_ = iterator_type::create(o->addrinfo_,
             o->query_.host_name(), o->query_.service_name());
       }
       p.reset();
diff --git a/3rdParty/Boost/src/boost/asio/detail/resolver_service.hpp b/3rdParty/Boost/src/boost/asio/detail/resolver_service.hpp
index 8225844..4ba295d 100644
--- a/3rdParty/Boost/src/boost/asio/detail/resolver_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/resolver_service.hpp
@@ -1,11 +1,11 @@
 //
 // detail/resolver_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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_RESOLVER_SERVICE_HPP
@@ -13,14 +13,18 @@
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
+
+#if !defined(BOOST_ASIO_WINDOWS_RUNTIME)
+
 #include <boost/asio/ip/basic_resolver_iterator.hpp>
 #include <boost/asio/ip/basic_resolver_query.hpp>
+#include <boost/asio/detail/addressof.hpp>
 #include <boost/asio/detail/resolve_endpoint_op.hpp>
 #include <boost/asio/detail/resolve_op.hpp>
 #include <boost/asio/detail/resolver_service_base.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
@@ -65,17 +69,17 @@ public:
         address_info, query.host_name(), query.service_name());
   }
 
   // Asynchronously resolve a query to a list of entries.
   template <typename Handler>
   void async_resolve(implementation_type& impl,
-      const query_type& query, Handler handler)
+      const query_type& query, Handler& handler)
   {
     // Allocate and construct an operation to wrap the handler.
     typedef resolve_op<Protocol, Handler> op;
-    typename op::ptr p = { boost::addressof(handler),
+    typename op::ptr p = { boost::asio::detail::addressof(handler),
       boost_asio_handler_alloc_helpers::allocate(
         sizeof(op), handler), 0 };
     p.p = new (p.v) op(impl, query, io_service_impl_, handler);
 
     BOOST_ASIO_HANDLER_CREATION((p.p, "resolver", &impl, "async_resolve"));
 
@@ -97,17 +101,17 @@ public:
         endpoint, host_name, service_name);
   }
 
   // Asynchronously resolve an endpoint to a list of entries.
   template <typename Handler>
   void async_resolve(implementation_type& impl,
-      const endpoint_type& endpoint, Handler handler)
+      const endpoint_type& endpoint, Handler& handler)
   {
     // Allocate and construct an operation to wrap the handler.
     typedef resolve_endpoint_op<Protocol, Handler> op;
-    typename op::ptr p = { boost::addressof(handler),
+    typename op::ptr p = { boost::asio::detail::addressof(handler),
       boost_asio_handler_alloc_helpers::allocate(
         sizeof(op), handler), 0 };
     p.p = new (p.v) op(impl, endpoint, io_service_impl_, handler);
 
     BOOST_ASIO_HANDLER_CREATION((p.p, "resolver", &impl, "async_resolve"));
 
@@ -119,7 +123,9 @@ public:
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
+#endif // !defined(BOOST_ASIO_WINDOWS_RUNTIME)
+
 #endif // BOOST_ASIO_DETAIL_RESOLVER_SERVICE_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/resolver_service_base.hpp b/3rdParty/Boost/src/boost/asio/detail/resolver_service_base.hpp
index 3a48d06..0c00896 100644
--- a/3rdParty/Boost/src/boost/asio/detail/resolver_service_base.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/resolver_service_base.hpp
@@ -1,11 +1,11 @@
 //
 // detail/resolver_service_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)
 //
 // 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_DETAIL_RESOLVER_SERVICE_BASE_HPP
@@ -62,12 +62,13 @@ public:
   BOOST_ASIO_DECL void cancel(implementation_type& impl);
 
 protected:
   // Helper function to start an asynchronous resolve operation.
   BOOST_ASIO_DECL void start_resolve_op(operation* op);
 
+#if !defined(BOOST_ASIO_WINDOWS_RUNTIME)
   // Helper class to perform exception-safe cleanup of addrinfo objects.
   class auto_addrinfo
     : private boost::asio::detail::noncopyable
   {
   public:
     explicit auto_addrinfo(boost::asio::detail::addrinfo_type* ai)
@@ -86,12 +87,13 @@ protected:
       return ai_;
     }
 
   private:
     boost::asio::detail::addrinfo_type* ai_;
   };
+#endif // !defined(BOOST_ASIO_WINDOWS_RUNTIME)
 
   // Helper class to run the work io_service in a thread.
   class work_io_service_runner;
 
   // Start the work thread if it's not already running.
   BOOST_ASIO_DECL void start_work_thread();
diff --git a/3rdParty/Boost/src/boost/asio/detail/scoped_lock.hpp b/3rdParty/Boost/src/boost/asio/detail/scoped_lock.hpp
index a2e6fd4..848864e 100644
--- a/3rdParty/Boost/src/boost/asio/detail/scoped_lock.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/scoped_lock.hpp
@@ -1,11 +1,11 @@
 //
 // detail/scoped_lock.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_SCOPED_LOCK_HPP
@@ -26,14 +26,24 @@ namespace detail {
 // Helper class to lock and unlock a mutex automatically.
 template <typename Mutex>
 class scoped_lock
   : private noncopyable
 {
 public:
+  // Tag type used to distinguish constructors.
+  enum adopt_lock_t { adopt_lock };
+
+  // Constructor adopts a lock that is already held.
+  scoped_lock(Mutex& m, adopt_lock_t)
+    : mutex_(m),
+      locked_(true)
+  {
+  }
+
   // Constructor acquires the lock.
-  scoped_lock(Mutex& m)
+  explicit scoped_lock(Mutex& m)
     : mutex_(m)
   {
     mutex_.lock();
     locked_ = true;
   }
 
diff --git a/3rdParty/Boost/src/boost/asio/detail/scoped_ptr.hpp b/3rdParty/Boost/src/boost/asio/detail/scoped_ptr.hpp
index 16436dd..5df78f7 100644
--- a/3rdParty/Boost/src/boost/asio/detail/scoped_ptr.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/scoped_ptr.hpp
@@ -1,11 +1,11 @@
 //
 // detail/scoped_ptr.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_SCOPED_PTR_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/select_interrupter.hpp b/3rdParty/Boost/src/boost/asio/detail/select_interrupter.hpp
index 11a4967..4f802d1 100644
--- a/3rdParty/Boost/src/boost/asio/detail/select_interrupter.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/select_interrupter.hpp
@@ -1,11 +1,11 @@
 //
 // detail/select_interrupter.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_SELECT_INTERRUPTER_HPP
@@ -14,31 +14,35 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__) || defined(__SYMBIAN32__)
+#if !defined(BOOST_ASIO_WINDOWS_RUNTIME)
+
+#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) || defined(__SYMBIAN32__)
 # include <boost/asio/detail/socket_select_interrupter.hpp>
 #elif defined(BOOST_ASIO_HAS_EVENTFD)
 # include <boost/asio/detail/eventfd_select_interrupter.hpp>
 #else
 # include <boost/asio/detail/pipe_select_interrupter.hpp>
 #endif
 
 namespace boost {
 namespace asio {
 namespace detail {
 
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__) || defined(__SYMBIAN32__)
+#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__) || defined(__SYMBIAN32__)
 typedef socket_select_interrupter select_interrupter;
 #elif defined(BOOST_ASIO_HAS_EVENTFD)
 typedef eventfd_select_interrupter select_interrupter;
 #else
 typedef pipe_select_interrupter select_interrupter;
 #endif
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
+#endif // !defined(BOOST_ASIO_WINDOWS_RUNTIME)
+
 #endif // BOOST_ASIO_DETAIL_SELECT_INTERRUPTER_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/select_reactor.hpp b/3rdParty/Boost/src/boost/asio/detail/select_reactor.hpp
index a434546..6d3b243 100644
--- a/3rdParty/Boost/src/boost/asio/detail/select_reactor.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/select_reactor.hpp
@@ -1,11 +1,11 @@
 //
 // detail/select_reactor.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_SELECT_REACTOR_HPP
@@ -17,26 +17,25 @@
 
 #include <boost/asio/detail/config.hpp>
 
 #if defined(BOOST_ASIO_HAS_IOCP) \
   || (!defined(BOOST_ASIO_HAS_DEV_POLL) \
       && !defined(BOOST_ASIO_HAS_EPOLL) \
-      && !defined(BOOST_ASIO_HAS_KQUEUE))
+      && !defined(BOOST_ASIO_HAS_KQUEUE) \
+      && !defined(BOOST_ASIO_WINDOWS_RUNTIME))
 
-#include <boost/limits.hpp>
 #include <cstddef>
 #include <boost/asio/detail/fd_set_adapter.hpp>
+#include <boost/asio/detail/limits.hpp>
 #include <boost/asio/detail/mutex.hpp>
 #include <boost/asio/detail/op_queue.hpp>
 #include <boost/asio/detail/reactor_op.hpp>
 #include <boost/asio/detail/reactor_op_queue.hpp>
 #include <boost/asio/detail/select_interrupter.hpp>
-#include <boost/asio/detail/select_reactor_fwd.hpp>
 #include <boost/asio/detail/socket_types.hpp>
 #include <boost/asio/detail/timer_queue_base.hpp>
-#include <boost/asio/detail/timer_queue_fwd.hpp>
 #include <boost/asio/detail/timer_queue_set.hpp>
 #include <boost/asio/detail/wait_op.hpp>
 #include <boost/asio/io_service.hpp>
 
 #if defined(BOOST_ASIO_HAS_IOCP)
 # include <boost/asio/detail/thread.hpp>
@@ -49,19 +48,19 @@ namespace asio {
 namespace detail {
 
 class select_reactor
   : public boost::asio::detail::service_base<select_reactor>
 {
 public:
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   enum op_types { read_op = 0, write_op = 1, except_op = 2,
     max_select_ops = 3, connect_op = 3, max_ops = 4 };
-#else // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   enum op_types { read_op = 0, write_op = 1, except_op = 2,
     max_select_ops = 3, connect_op = 1, max_ops = 3 };
-#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 
   // Per-descriptor data.
   struct per_descriptor_data
   {
   };
 
@@ -89,21 +88,21 @@ public:
   // success, system error code on failure.
   BOOST_ASIO_DECL int register_internal_descriptor(
       int op_type, socket_type descriptor,
       per_descriptor_data& descriptor_data, reactor_op* op);
 
   // Post a reactor operation for immediate completion.
-  void post_immediate_completion(reactor_op* op)
+  void post_immediate_completion(reactor_op* op, bool is_continuation)
   {
-    io_service_.post_immediate_completion(op);
+    io_service_.post_immediate_completion(op, is_continuation);
   }
 
   // Start a new operation. The reactor operation will be performed when the
   // given descriptor is flagged as ready, or an error has occurred.
   BOOST_ASIO_DECL void start_op(int op_type, socket_type descriptor,
-      per_descriptor_data&, reactor_op* op, bool);
+      per_descriptor_data&, reactor_op* op, bool is_continuation, bool);
 
   // Cancel all operations associated with the given descriptor. The
   // handlers associated with the descriptor will be invoked with the
   // operation_aborted error.
   BOOST_ASIO_DECL void cancel_ops(socket_type descriptor, per_descriptor_data&);
 
@@ -213,9 +212,10 @@ private:
 # include <boost/asio/detail/impl/select_reactor.ipp>
 #endif // defined(BOOST_ASIO_HEADER_ONLY)
 
 #endif // defined(BOOST_ASIO_HAS_IOCP)
        //   || (!defined(BOOST_ASIO_HAS_DEV_POLL)
        //       && !defined(BOOST_ASIO_HAS_EPOLL)
-       //       && !defined(BOOST_ASIO_HAS_KQUEUE))
+       //       && !defined(BOOST_ASIO_HAS_KQUEUE)
+       //       && !defined(BOOST_ASIO_WINDOWS_RUNTIME))
 
 #endif // BOOST_ASIO_DETAIL_SELECT_REACTOR_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/select_reactor_fwd.hpp b/3rdParty/Boost/src/boost/asio/detail/select_reactor_fwd.hpp
deleted file mode 100644
index 1337969..0000000
--- a/3rdParty/Boost/src/boost/asio/detail/select_reactor_fwd.hpp
+++ /dev/null
@@ -1,28 +0,0 @@
-//
-// detail/select_reactor_fwd.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2012 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_DETAIL_SELECT_REACTOR_FWD_HPP
-#define BOOST_ASIO_DETAIL_SELECT_REACTOR_FWD_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-namespace boost {
-namespace asio {
-namespace detail {
-
-class select_reactor;
-
-} // namespace detail
-} // namespace asio
-} // namespace boost
-
-#endif // BOOST_ASIO_DETAIL_SELECT_REACTOR_FWD_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/service_registry.hpp b/3rdParty/Boost/src/boost/asio/detail/service_registry.hpp
index 458f271..bfd80fc 100644
--- a/3rdParty/Boost/src/boost/asio/detail/service_registry.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/service_registry.hpp
@@ -1,11 +1,11 @@
 //
 // detail/service_registry.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_SERVICE_REGISTRY_HPP
@@ -18,18 +18,12 @@
 #include <boost/asio/detail/config.hpp>
 #include <typeinfo>
 #include <boost/asio/detail/mutex.hpp>
 #include <boost/asio/detail/noncopyable.hpp>
 #include <boost/asio/io_service.hpp>
 
-#if defined(BOOST_NO_TYPEID)
-# if !defined(BOOST_ASIO_NO_TYPEID)
-#  define BOOST_ASIO_NO_TYPEID
-# endif // !defined(BOOST_ASIO_NO_TYPEID)
-#endif // defined(BOOST_NO_TYPEID)
-
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
diff --git a/3rdParty/Boost/src/boost/asio/detail/service_registry_fwd.hpp b/3rdParty/Boost/src/boost/asio/detail/service_registry_fwd.hpp
deleted file mode 100644
index 3157574..0000000
--- a/3rdParty/Boost/src/boost/asio/detail/service_registry_fwd.hpp
+++ /dev/null
@@ -1,28 +0,0 @@
-//
-// detail/service_registry_fwd.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2012 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_DETAIL_SERVICE_REGISTRY_FWD_HPP
-#define BOOST_ASIO_DETAIL_SERVICE_REGISTRY_FWD_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-namespace boost {
-namespace asio {
-namespace detail {
-
-class service_registry;
-
-} // namespace detail
-} // namespace asio
-} // namespace boost
-
-#endif // BOOST_ASIO_DETAIL_SERVICE_REGISTRY_FWD_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/shared_ptr.hpp b/3rdParty/Boost/src/boost/asio/detail/shared_ptr.hpp
index 5f0da22..3c79f61 100644
--- a/3rdParty/Boost/src/boost/asio/detail/shared_ptr.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/shared_ptr.hpp
@@ -1,11 +1,11 @@
 //
 // detail/shared_ptr.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_SHARED_PTR_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/signal_blocker.hpp b/3rdParty/Boost/src/boost/asio/detail/signal_blocker.hpp
index fe859b4..ad6baba 100644
--- a/3rdParty/Boost/src/boost/asio/detail/signal_blocker.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/signal_blocker.hpp
@@ -1,11 +1,11 @@
 //
 // detail/signal_blocker.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_SIGNAL_BLOCKER_HPP
@@ -14,29 +14,31 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
-#if !defined(BOOST_HAS_THREADS) || defined(BOOST_ASIO_DISABLE_THREADS) \
-  || defined(BOOST_WINDOWS) || defined(__CYGWIN__) || defined(__SYMBIAN32__)
+#if !defined(BOOST_ASIO_HAS_THREADS) || defined(BOOST_ASIO_WINDOWS) \
+  || defined(BOOST_ASIO_WINDOWS_RUNTIME) \
+  || defined(__CYGWIN__) || defined(__SYMBIAN32__)
 # include <boost/asio/detail/null_signal_blocker.hpp>
-#elif defined(BOOST_HAS_PTHREADS)
+#elif defined(BOOST_ASIO_HAS_PTHREADS)
 # include <boost/asio/detail/posix_signal_blocker.hpp>
 #else
 # error Only Windows and POSIX are supported!
 #endif
 
 namespace boost {
 namespace asio {
 namespace detail {
 
-#if !defined(BOOST_HAS_THREADS) || defined(BOOST_ASIO_DISABLE_THREADS) \
-  || defined(BOOST_WINDOWS) || defined(__CYGWIN__) || defined(__SYMBIAN32__)
+#if !defined(BOOST_ASIO_HAS_THREADS) || defined(BOOST_ASIO_WINDOWS) \
+  || defined(BOOST_ASIO_WINDOWS_RUNTIME) \
+  || defined(__CYGWIN__) || defined(__SYMBIAN32__)
 typedef null_signal_blocker signal_blocker;
-#elif defined(BOOST_HAS_PTHREADS)
+#elif defined(BOOST_ASIO_HAS_PTHREADS)
 typedef posix_signal_blocker signal_blocker;
 #endif
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
diff --git a/3rdParty/Boost/src/boost/asio/detail/signal_handler.hpp b/3rdParty/Boost/src/boost/asio/detail/signal_handler.hpp
index bd1c727..32ce844 100644
--- a/3rdParty/Boost/src/boost/asio/detail/signal_handler.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/signal_handler.hpp
@@ -1,11 +1,11 @@
 //
 // detail/signal_handler.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_SIGNAL_HANDLER_HPP
@@ -13,12 +13,13 @@
 
 #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/addressof.hpp>
 #include <boost/asio/detail/fenced_block.hpp>
 #include <boost/asio/detail/handler_alloc_helpers.hpp>
 #include <boost/asio/detail/handler_invoke_helpers.hpp>
 #include <boost/asio/detail/signal_op.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
@@ -42,25 +43,25 @@ public:
   static void do_complete(io_service_impl* owner, operation* base,
       const boost::system::error_code& /*ec*/,
       std::size_t /*bytes_transferred*/)
   {
     // Take ownership of the handler object.
     signal_handler* h(static_cast<signal_handler*>(base));
-    ptr p = { boost::addressof(h->handler_), h, h };
+    ptr p = { boost::asio::detail::addressof(h->handler_), h, h };
 
     BOOST_ASIO_HANDLER_COMPLETION((h));
 
     // Make a copy of the handler so that the memory can be deallocated before
     // the upcall is made. Even if we're not about to make an upcall, a
     // sub-object of the handler may be the true owner of the memory associated
     // with the handler. Consequently, a local copy of the handler is required
     // to ensure that any owning sub-object remains valid until after we have
     // deallocated the memory here.
     detail::binder2<Handler, boost::system::error_code, int>
       handler(h->handler_, h->ec_, h->signal_number_);
-    p.h = boost::addressof(handler.handler_);
+    p.h = boost::asio::detail::addressof(handler.handler_);
     p.reset();
 
     // Make the upcall if required.
     if (owner)
     {
       fenced_block b(fenced_block::half);
diff --git a/3rdParty/Boost/src/boost/asio/detail/signal_init.hpp b/3rdParty/Boost/src/boost/asio/detail/signal_init.hpp
index e038a88..0dc6558 100644
--- a/3rdParty/Boost/src/boost/asio/detail/signal_init.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/signal_init.hpp
@@ -1,11 +1,11 @@
 //
 // detail/signal_init.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_SIGNAL_INIT_HPP
@@ -14,13 +14,13 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
-#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+#if !defined(BOOST_ASIO_WINDOWS) && !defined(__CYGWIN__)
 
 #include <csignal>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
@@ -41,9 +41,9 @@ public:
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
-#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+#endif // !defined(BOOST_ASIO_WINDOWS) && !defined(__CYGWIN__)
 
 #endif // BOOST_ASIO_DETAIL_SIGNAL_INIT_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/signal_op.hpp b/3rdParty/Boost/src/boost/asio/detail/signal_op.hpp
index 706691b..e75d412 100644
--- a/3rdParty/Boost/src/boost/asio/detail/signal_op.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/signal_op.hpp
@@ -1,11 +1,11 @@
 //
 // detail/signal_op.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_SIGNAL_OP_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/signal_set_service.hpp b/3rdParty/Boost/src/boost/asio/detail/signal_set_service.hpp
index afa67fe..9949f04 100644
--- a/3rdParty/Boost/src/boost/asio/detail/signal_set_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/signal_set_service.hpp
@@ -1,11 +1,11 @@
 //
 // detail/signal_set_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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_SIGNAL_SET_SERVICE_HPP
@@ -18,21 +18,22 @@
 #include <boost/asio/detail/config.hpp>
 
 #include <cstddef>
 #include <signal.h>
 #include <boost/asio/error.hpp>
 #include <boost/asio/io_service.hpp>
+#include <boost/asio/detail/addressof.hpp>
 #include <boost/asio/detail/handler_alloc_helpers.hpp>
 #include <boost/asio/detail/op_queue.hpp>
 #include <boost/asio/detail/signal_handler.hpp>
 #include <boost/asio/detail/signal_op.hpp>
 #include <boost/asio/detail/socket_types.hpp>
 
-#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+#if !defined(BOOST_ASIO_WINDOWS) && !defined(__CYGWIN__)
 # include <boost/asio/detail/reactor.hpp>
-#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+#endif // !defined(BOOST_ASIO_WINDOWS) && !defined(__CYGWIN__)
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
@@ -42,13 +43,13 @@ enum { max_signal_number = NSIG };
 #else
 enum { max_signal_number = 128 };
 #endif
 
 extern BOOST_ASIO_DECL struct signal_state* get_signal_state();
 
-extern "C" BOOST_ASIO_DECL void asio_signal_handler(int signal_number);
+extern "C" BOOST_ASIO_DECL void boost_asio_signal_handler(int signal_number);
 
 class signal_set_service
 {
 public:
   // Type used for tracking an individual signal registration.
   class registration
@@ -141,17 +142,17 @@ public:
   // Cancel all operations associated with the signal set.
   BOOST_ASIO_DECL boost::system::error_code cancel(implementation_type& impl,
       boost::system::error_code& ec);
 
   // Start an asynchronous operation to wait for a signal to be delivered.
   template <typename Handler>
-  void async_wait(implementation_type& impl, Handler handler)
+  void async_wait(implementation_type& impl, Handler& handler)
   {
     // Allocate and construct an operation to wrap the handler.
     typedef signal_handler<Handler> op;
-    typename op::ptr p = { boost::addressof(handler),
+    typename op::ptr p = { boost::asio::detail::addressof(handler),
       boost_asio_handler_alloc_helpers::allocate(
         sizeof(op), handler), 0 };
     p.p = new (p.v) op(handler);
 
     BOOST_ASIO_HANDLER_CREATION((p.p, "signal_set", &impl, "async_wait"));
 
@@ -178,22 +179,26 @@ private:
   // Helper function to start a wait operation.
   BOOST_ASIO_DECL void start_wait_op(implementation_type& impl, signal_op* op);
 
   // The io_service instance used for dispatching handlers.
   io_service_impl& io_service_;
 
-#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+#if !defined(BOOST_ASIO_WINDOWS) \
+  && !defined(BOOST_ASIO_WINDOWS_RUNTIME) \
+  && !defined(__CYGWIN__)
   // The type used for registering for pipe reactor notifications.
   class pipe_read_op;
 
   // The reactor used for waiting for pipe readiness.
   reactor& reactor_;
 
   // The per-descriptor reactor data used for the pipe.
   reactor::per_descriptor_data reactor_data_;
-#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+#endif // !defined(BOOST_ASIO_WINDOWS)
+       //   && !defined(BOOST_ASIO_WINDOWS_RUNTIME)
+       //   && !defined(__CYGWIN__)
 
   // A mapping from signal number to the registered signal sets.
   registration* registrations_[max_signal_number];
 
   // Pointers to adjacent services in linked list.
   signal_set_service* next_;
diff --git a/3rdParty/Boost/src/boost/asio/detail/socket_holder.hpp b/3rdParty/Boost/src/boost/asio/detail/socket_holder.hpp
index d299859..81f4142 100644
--- a/3rdParty/Boost/src/boost/asio/detail/socket_holder.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/socket_holder.hpp
@@ -1,11 +1,11 @@
 //
 // detail/socket_holder.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_SOCKET_HOLDER_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/socket_ops.hpp b/3rdParty/Boost/src/boost/asio/detail/socket_ops.hpp
index b353316..04a28ef 100644
--- a/3rdParty/Boost/src/boost/asio/detail/socket_ops.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/socket_ops.hpp
@@ -1,11 +1,11 @@
 //
 // detail/socket_ops.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_SOCKET_OPS_HPP
@@ -60,12 +60,14 @@ enum
 typedef unsigned char state_type;
 
 struct noop_deleter { void operator()(void*) {} };
 typedef shared_ptr<void> shared_cancel_token_type;
 typedef weak_ptr<void> weak_cancel_token_type;
 
+#if !defined(BOOST_ASIO_WINDOWS_RUNTIME)
+
 BOOST_ASIO_DECL socket_type accept(socket_type s, socket_addr_type* addr,
     std::size_t* addrlen, boost::system::error_code& ec);
 
 BOOST_ASIO_DECL socket_type sync_accept(socket_type s,
     state_type state, socket_addr_type* addr,
     std::size_t* addrlen, boost::system::error_code& ec);
@@ -103,37 +105,44 @@ BOOST_ASIO_DECL int shutdown(socket_type s,
 BOOST_ASIO_DECL int connect(socket_type s, const socket_addr_type* addr,
     std::size_t addrlen, boost::system::error_code& ec);
 
 BOOST_ASIO_DECL void sync_connect(socket_type s, const socket_addr_type* addr,
     std::size_t addrlen, boost::system::error_code& ec);
 
-BOOST_ASIO_DECL bool non_blocking_connect(
-    socket_type s, boost::system::error_code& ec);
+#if defined(BOOST_ASIO_HAS_IOCP)
+
+BOOST_ASIO_DECL void complete_iocp_connect(socket_type s,
+    boost::system::error_code& ec);
+
+#endif // defined(BOOST_ASIO_HAS_IOCP)
+
+BOOST_ASIO_DECL bool non_blocking_connect(socket_type s,
+    boost::system::error_code& ec);
 
 BOOST_ASIO_DECL int socketpair(int af, int type, int protocol,
     socket_type sv[2], boost::system::error_code& ec);
 
 BOOST_ASIO_DECL bool sockatmark(socket_type s, boost::system::error_code& ec);
 
 BOOST_ASIO_DECL size_t available(socket_type s, boost::system::error_code& ec);
 
 BOOST_ASIO_DECL int listen(socket_type s,
     int backlog, boost::system::error_code& ec);
 
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 typedef WSABUF buf;
-#else // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#else // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 typedef iovec buf;
-#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 
 BOOST_ASIO_DECL void init_buf(buf& b, void* data, size_t size);
 
 BOOST_ASIO_DECL void init_buf(buf& b, const void* data, size_t size);
 
-BOOST_ASIO_DECL int recv(socket_type s, buf* bufs, size_t count, int flags,
-    boost::system::error_code& ec);
+BOOST_ASIO_DECL signed_size_type recv(socket_type s, buf* bufs,
+    size_t count, int flags, boost::system::error_code& ec);
 
 BOOST_ASIO_DECL size_t sync_recv(socket_type s, state_type state, buf* bufs,
     size_t count, int flags, bool all_empty, boost::system::error_code& ec);
 
 #if defined(BOOST_ASIO_HAS_IOCP)
 
@@ -146,15 +155,15 @@ BOOST_ASIO_DECL void complete_iocp_recv(state_type state,
 BOOST_ASIO_DECL bool non_blocking_recv(socket_type s,
     buf* bufs, size_t count, int flags, bool is_stream,
     boost::system::error_code& ec, size_t& bytes_transferred);
 
 #endif // defined(BOOST_ASIO_HAS_IOCP)
 
-BOOST_ASIO_DECL int recvfrom(socket_type s, buf* bufs, size_t count, int flags,
-    socket_addr_type* addr, std::size_t* addrlen,
-    boost::system::error_code& ec);
+BOOST_ASIO_DECL signed_size_type recvfrom(socket_type s, buf* bufs,
+    size_t count, int flags, socket_addr_type* addr,
+    std::size_t* addrlen, boost::system::error_code& ec);
 
 BOOST_ASIO_DECL size_t sync_recvfrom(socket_type s, state_type state,
     buf* bufs, size_t count, int flags, socket_addr_type* addr,
     std::size_t* addrlen, boost::system::error_code& ec);
 
 #if defined(BOOST_ASIO_HAS_IOCP)
@@ -169,14 +178,15 @@ BOOST_ASIO_DECL bool non_blocking_recvfrom(socket_type s,
     buf* bufs, size_t count, int flags,
     socket_addr_type* addr, std::size_t* addrlen,
     boost::system::error_code& ec, size_t& bytes_transferred);
 
 #endif // defined(BOOST_ASIO_HAS_IOCP)
 
-BOOST_ASIO_DECL int recvmsg(socket_type s, buf* bufs, size_t count,
-    int in_flags, int& out_flags, boost::system::error_code& ec);
+BOOST_ASIO_DECL signed_size_type recvmsg(socket_type s, buf* bufs,
+    size_t count, int in_flags, int& out_flags,
+    boost::system::error_code& ec);
 
 BOOST_ASIO_DECL size_t sync_recvmsg(socket_type s, state_type state,
     buf* bufs, size_t count, int in_flags, int& out_flags,
     boost::system::error_code& ec);
 
 #if defined(BOOST_ASIO_HAS_IOCP)
@@ -190,13 +200,13 @@ BOOST_ASIO_DECL void complete_iocp_recvmsg(
 BOOST_ASIO_DECL bool non_blocking_recvmsg(socket_type s,
     buf* bufs, size_t count, int in_flags, int& out_flags,
     boost::system::error_code& ec, size_t& bytes_transferred);
 
 #endif // defined(BOOST_ASIO_HAS_IOCP)
 
-BOOST_ASIO_DECL int send(socket_type s, const buf* bufs,
+BOOST_ASIO_DECL signed_size_type send(socket_type s, const buf* bufs,
     size_t count, int flags, boost::system::error_code& ec);
 
 BOOST_ASIO_DECL size_t sync_send(socket_type s, state_type state,
     const buf* bufs, size_t count, int flags,
     bool all_empty, boost::system::error_code& ec);
 
@@ -211,15 +221,15 @@ BOOST_ASIO_DECL void complete_iocp_send(
 BOOST_ASIO_DECL bool non_blocking_send(socket_type s,
     const buf* bufs, size_t count, int flags,
     boost::system::error_code& ec, size_t& bytes_transferred);
 
 #endif // defined(BOOST_ASIO_HAS_IOCP)
 
-BOOST_ASIO_DECL int sendto(socket_type s, const buf* bufs, size_t count,
-    int flags, const socket_addr_type* addr, std::size_t addrlen,
-    boost::system::error_code& ec);
+BOOST_ASIO_DECL signed_size_type sendto(socket_type s, const buf* bufs,
+    size_t count, int flags, const socket_addr_type* addr,
+    std::size_t addrlen, boost::system::error_code& ec);
 
 BOOST_ASIO_DECL size_t sync_sendto(socket_type s, state_type state,
     const buf* bufs, size_t count, int flags, const socket_addr_type* addr,
     std::size_t addrlen, boost::system::error_code& ec);
 
 #if !defined(BOOST_ASIO_HAS_IOCP)
@@ -259,21 +269,25 @@ BOOST_ASIO_DECL int poll_read(socket_type s,
 
 BOOST_ASIO_DECL int poll_write(socket_type s,
     state_type state, boost::system::error_code& ec);
 
 BOOST_ASIO_DECL int poll_connect(socket_type s, boost::system::error_code& ec);
 
+#endif // !defined(BOOST_ASIO_WINDOWS_RUNTIME)
+
 BOOST_ASIO_DECL const char* inet_ntop(int af, const void* src, char* dest,
     size_t length, unsigned long scope_id, boost::system::error_code& ec);
 
 BOOST_ASIO_DECL int inet_pton(int af, const char* src, void* dest,
     unsigned long* scope_id, boost::system::error_code& ec);
 
 BOOST_ASIO_DECL int gethostname(char* name,
     int namelen, boost::system::error_code& ec);
 
+#if !defined(BOOST_ASIO_WINDOWS_RUNTIME)
+
 BOOST_ASIO_DECL boost::system::error_code getaddrinfo(const char* host,
     const char* service, const addrinfo_type& hints,
     addrinfo_type** result, boost::system::error_code& ec);
 
 BOOST_ASIO_DECL boost::system::error_code background_getaddrinfo(
     const weak_cancel_token_type& cancel_token, const char* host,
@@ -295,12 +309,14 @@ BOOST_ASIO_DECL boost::system::error_code sync_getnameinfo(
 BOOST_ASIO_DECL boost::system::error_code background_getnameinfo(
     const weak_cancel_token_type& cancel_token,
     const socket_addr_type* addr, std::size_t addrlen,
     char* host, std::size_t hostlen, char* serv,
     std::size_t servlen, int sock_type, boost::system::error_code& ec);
 
+#endif // !defined(BOOST_ASIO_WINDOWS_RUNTIME)
+
 BOOST_ASIO_DECL u_long_type network_to_host_long(u_long_type value);
 
 BOOST_ASIO_DECL u_long_type host_to_network_long(u_long_type value);
 
 BOOST_ASIO_DECL u_short_type network_to_host_short(u_short_type value);
 
diff --git a/3rdParty/Boost/src/boost/asio/detail/socket_option.hpp b/3rdParty/Boost/src/boost/asio/detail/socket_option.hpp
index 5d3a514..2fe5ee4 100644
--- a/3rdParty/Boost/src/boost/asio/detail/socket_option.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/socket_option.hpp
@@ -1,11 +1,11 @@
 //
 // detail/socket_option.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_SOCKET_OPTION_HPP
@@ -15,15 +15,14 @@
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 #include <cstddef>
 #include <stdexcept>
-#include <boost/config.hpp>
-#include <boost/throw_exception.hpp>
 #include <boost/asio/detail/socket_types.hpp>
+#include <boost/asio/detail/throw_exception.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
@@ -120,13 +119,13 @@ public:
       break;
     case sizeof(value_):
       break;
     default:
       {
         std::length_error ex("boolean socket option resize");
-        boost::throw_exception(ex);
+        boost::asio::detail::throw_exception(ex);
       }
     }
   }
 
 private:
   int value_;
@@ -201,13 +200,13 @@ public:
   template <typename Protocol>
   void resize(const Protocol&, std::size_t s)
   {
     if (s != sizeof(value_))
     {
       std::length_error ex("integer socket option resize");
-      boost::throw_exception(ex);
+      boost::asio::detail::throw_exception(ex);
     }
   }
 
 private:
   int value_;
 };
@@ -225,13 +224,13 @@ public:
   }
 
   // Construct with specific option values.
   linger(bool e, int t)
   {
     enabled(e);
-    timeout BOOST_PREVENT_MACRO_SUBSTITUTION(t);
+    timeout BOOST_ASIO_PREVENT_MACRO_SUBSTITUTION(t);
   }
 
   // Set the value for whether linger is enabled.
   void enabled(bool value)
   {
     value_.l_onoff = value ? 1 : 0;
@@ -241,23 +240,23 @@ public:
   bool enabled() const
   {
     return value_.l_onoff != 0;
   }
 
   // Set the value for the linger timeout.
-  void timeout BOOST_PREVENT_MACRO_SUBSTITUTION(int value)
+  void timeout BOOST_ASIO_PREVENT_MACRO_SUBSTITUTION(int value)
   {
 #if defined(WIN32)
     value_.l_linger = static_cast<u_short>(value);
 #else
     value_.l_linger = value;
 #endif
   }
 
   // Get the value for the linger timeout.
-  int timeout BOOST_PREVENT_MACRO_SUBSTITUTION() const
+  int timeout BOOST_ASIO_PREVENT_MACRO_SUBSTITUTION() const
   {
     return static_cast<int>(value_.l_linger);
   }
 
   // Get the level of the socket option.
   template <typename Protocol>
@@ -272,20 +271,20 @@ public:
   {
     return Name;
   }
 
   // Get the address of the linger data.
   template <typename Protocol>
-  ::linger* data(const Protocol&)
+  detail::linger_type* data(const Protocol&)
   {
     return &value_;
   }
 
   // Get the address of the linger data.
   template <typename Protocol>
-  const ::linger* data(const Protocol&) const
+  const detail::linger_type* data(const Protocol&) const
   {
     return &value_;
   }
 
   // Get the size of the linger data.
   template <typename Protocol>
@@ -298,18 +297,18 @@ public:
   template <typename Protocol>
   void resize(const Protocol&, std::size_t s)
   {
     if (s != sizeof(value_))
     {
       std::length_error ex("linger socket option resize");
-      boost::throw_exception(ex);
+      boost::asio::detail::throw_exception(ex);
     }
   }
 
 private:
-  ::linger value_;
+  detail::linger_type value_;
 };
 
 } // namespace socket_option
 } // namespace detail
 } // namespace asio
 } // namespace boost
diff --git a/3rdParty/Boost/src/boost/asio/detail/socket_select_interrupter.hpp b/3rdParty/Boost/src/boost/asio/detail/socket_select_interrupter.hpp
index eb8c7d0..38f140d 100644
--- a/3rdParty/Boost/src/boost/asio/detail/socket_select_interrupter.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/socket_select_interrupter.hpp
@@ -1,11 +1,11 @@
 //
 // detail/socket_select_interrupter.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_SOCKET_SELECT_INTERRUPTER_HPP
@@ -14,13 +14,15 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
-#if defined(BOOST_WINDOWS) \
+#if !defined(BOOST_ASIO_WINDOWS_RUNTIME)
+
+#if defined(BOOST_ASIO_WINDOWS) \
   || defined(__CYGWIN__) \
   || defined(__SYMBIAN32__)
 
 #include <boost/asio/detail/socket_types.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
@@ -79,11 +81,13 @@ private:
 #include <boost/asio/detail/pop_options.hpp>
 
 #if defined(BOOST_ASIO_HEADER_ONLY)
 # include <boost/asio/detail/impl/socket_select_interrupter.ipp>
 #endif // defined(BOOST_ASIO_HEADER_ONLY)
 
-#endif // defined(BOOST_WINDOWS)
+#endif // defined(BOOST_ASIO_WINDOWS)
        // || defined(__CYGWIN__)
        // || defined(__SYMBIAN32__)
 
+#endif // !defined(BOOST_ASIO_WINDOWS_RUNTIME)
+
 #endif // BOOST_ASIO_DETAIL_SOCKET_SELECT_INTERRUPTER_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/socket_types.hpp b/3rdParty/Boost/src/boost/asio/detail/socket_types.hpp
index 3754592..29e4739 100644
--- a/3rdParty/Boost/src/boost/asio/detail/socket_types.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/socket_types.hpp
@@ -1,11 +1,11 @@
 //
 // detail/socket_types.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_SOCKET_TYPES_HPP
@@ -14,23 +14,30 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#if defined(BOOST_ASIO_WINDOWS_RUNTIME)
+// Empty.
+#elif defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 # if defined(_WINSOCKAPI_) && !defined(_WINSOCK2API_)
 #  error WinSock.h has already been included
 # endif // defined(_WINSOCKAPI_) && !defined(_WINSOCK2API_)
 # if defined(__BORLANDC__)
 #  include <stdlib.h> // Needed for __errno
 #  if !defined(_WSPIAPI_H_)
 #   define _WSPIAPI_H_
 #   define BOOST_ASIO_WSPIAPI_H_DEFINED
 #  endif // !defined(_WSPIAPI_H_)
 # endif // defined(__BORLANDC__)
+# if defined(WINAPI_FAMILY)
+#  if ((WINAPI_FAMILY & WINAPI_PARTITION_DESKTOP) != 0)
+#   include <windows.h>
+#  endif // ((WINAPI_FAMILY & WINAPI_PARTITION_DESKTOP) != 0)
+# endif // defined(WINAPI_FAMILY)
 # include <winsock2.h>
 # include <ws2tcpip.h>
 # include <mswsock.h>
 # if defined(BOOST_ASIO_WSPIAPI_H_DEFINED)
 #  undef _WSPIAPI_H_
 #  undef BOOST_ASIO_WSPIAPI_H_DEFINED
@@ -78,13 +85,94 @@
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#if defined(BOOST_ASIO_WINDOWS_RUNTIME)
+const int max_addr_v4_str_len = 256;
+const int max_addr_v6_str_len = 256;
+typedef unsigned __int32 u_long_type;
+typedef unsigned __int16 u_short_type;
+struct in4_addr_type { u_long_type s_addr; };
+struct in4_mreq_type { in4_addr_type imr_multiaddr, imr_interface; };
+struct in6_addr_type { unsigned char s6_addr[16]; };
+struct in6_mreq_type { in6_addr_type ipv6mr_multiaddr;
+  unsigned long ipv6mr_interface; };
+struct socket_addr_type { int sa_family; };
+struct sockaddr_in4_type { int sin_family;
+  in4_addr_type sin_addr; u_short_type sin_port; };
+struct sockaddr_in6_type { int sin6_family;
+  in6_addr_type sin6_addr; u_short_type sin6_port;
+  u_long_type sin6_flowinfo; u_long_type sin6_scope_id; };
+struct sockaddr_storage_type { int ss_family;
+  unsigned char ss_bytes[128 - sizeof(int)]; };
+struct addrinfo_type { int ai_flags;
+  int ai_family, ai_socktype, ai_protocol;
+  int ai_addrlen; const void* ai_addr;
+  const char* ai_canonname; addrinfo_type* ai_next; };
+struct linger_type { u_short_type l_onoff, l_linger; };
+typedef u_long_type ioctl_arg_type;
+typedef int signed_size_type;
+# define BOOST_ASIO_OS_DEF(c) BOOST_ASIO_OS_DEF_##c
+# define BOOST_ASIO_OS_DEF_AF_UNSPEC 0
+# define BOOST_ASIO_OS_DEF_AF_INET 2
+# define BOOST_ASIO_OS_DEF_AF_INET6 23
+# define BOOST_ASIO_OS_DEF_SOCK_STREAM 1
+# define BOOST_ASIO_OS_DEF_SOCK_DGRAM 2
+# define BOOST_ASIO_OS_DEF_SOCK_RAW 3
+# define BOOST_ASIO_OS_DEF_SOCK_SEQPACKET 5
+# define BOOST_ASIO_OS_DEF_IPPROTO_IP 0
+# define BOOST_ASIO_OS_DEF_IPPROTO_IPV6 41
+# define BOOST_ASIO_OS_DEF_IPPROTO_TCP 6
+# define BOOST_ASIO_OS_DEF_IPPROTO_UDP 17
+# define BOOST_ASIO_OS_DEF_IPPROTO_ICMP 1
+# define BOOST_ASIO_OS_DEF_IPPROTO_ICMPV6 58
+# define BOOST_ASIO_OS_DEF_FIONBIO 1
+# define BOOST_ASIO_OS_DEF_FIONREAD 2
+# define BOOST_ASIO_OS_DEF_INADDR_ANY 0
+# define BOOST_ASIO_OS_DEF_MSG_OOB 0x1
+# define BOOST_ASIO_OS_DEF_MSG_PEEK 0x2
+# define BOOST_ASIO_OS_DEF_MSG_DONTROUTE 0x4
+# define BOOST_ASIO_OS_DEF_MSG_EOR 0 // Not supported.
+# define BOOST_ASIO_OS_DEF_SHUT_RD 0x0
+# define BOOST_ASIO_OS_DEF_SHUT_WR 0x1
+# define BOOST_ASIO_OS_DEF_SHUT_RDWR 0x2
+# define BOOST_ASIO_OS_DEF_SOMAXCONN 0x7fffffff
+# define BOOST_ASIO_OS_DEF_SOL_SOCKET 0xffff
+# define BOOST_ASIO_OS_DEF_SO_BROADCAST 0x20
+# define BOOST_ASIO_OS_DEF_SO_DEBUG 0x1
+# define BOOST_ASIO_OS_DEF_SO_DONTROUTE 0x10
+# define BOOST_ASIO_OS_DEF_SO_KEEPALIVE 0x8
+# define BOOST_ASIO_OS_DEF_SO_LINGER 0x80
+# define BOOST_ASIO_OS_DEF_SO_SNDBUF 0x1001
+# define BOOST_ASIO_OS_DEF_SO_RCVBUF 0x1002
+# define BOOST_ASIO_OS_DEF_SO_SNDLOWAT 0x1003
+# define BOOST_ASIO_OS_DEF_SO_RCVLOWAT 0x1004
+# define BOOST_ASIO_OS_DEF_SO_REUSEADDR 0x4
+# define BOOST_ASIO_OS_DEF_TCP_NODELAY 0x1
+# define BOOST_ASIO_OS_DEF_IP_MULTICAST_IF 2
+# define BOOST_ASIO_OS_DEF_IP_MULTICAST_TTL 3
+# define BOOST_ASIO_OS_DEF_IP_MULTICAST_LOOP 4
+# define BOOST_ASIO_OS_DEF_IP_ADD_MEMBERSHIP 5
+# define BOOST_ASIO_OS_DEF_IP_DROP_MEMBERSHIP 6
+# define BOOST_ASIO_OS_DEF_IP_TTL 7
+# define BOOST_ASIO_OS_DEF_IPV6_UNICAST_HOPS 4
+# define BOOST_ASIO_OS_DEF_IPV6_MULTICAST_IF 9
+# define BOOST_ASIO_OS_DEF_IPV6_MULTICAST_HOPS 10
+# define BOOST_ASIO_OS_DEF_IPV6_MULTICAST_LOOP 11
+# define BOOST_ASIO_OS_DEF_IPV6_JOIN_GROUP 12
+# define BOOST_ASIO_OS_DEF_IPV6_LEAVE_GROUP 13
+# define BOOST_ASIO_OS_DEF_AI_CANONNAME 0x2
+# define BOOST_ASIO_OS_DEF_AI_PASSIVE 0x1
+# define BOOST_ASIO_OS_DEF_AI_NUMERICHOST 0x4
+# define BOOST_ASIO_OS_DEF_AI_NUMERICSERV 0x8
+# define BOOST_ASIO_OS_DEF_AI_V4MAPPED 0x800
+# define BOOST_ASIO_OS_DEF_AI_ALL 0x100
+# define BOOST_ASIO_OS_DEF_AI_ADDRCONFIG 0x400
+#elif defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 typedef SOCKET socket_type;
 const SOCKET invalid_socket = INVALID_SOCKET;
 const int socket_error_retval = SOCKET_ERROR;
 const int max_addr_v4_str_len = 256;
 const int max_addr_v6_str_len = 256;
 typedef sockaddr socket_addr_type;
@@ -101,22 +189,89 @@ typedef addrinfo_emulation addrinfo_type;
 typedef in6_addr in6_addr_type;
 typedef ipv6_mreq in6_mreq_type;
 typedef sockaddr_in6 sockaddr_in6_type;
 typedef sockaddr_storage sockaddr_storage_type;
 typedef addrinfo addrinfo_type;
 # endif
+typedef ::linger linger_type;
 typedef unsigned long ioctl_arg_type;
 typedef u_long u_long_type;
 typedef u_short u_short_type;
-const int shutdown_receive = SD_RECEIVE;
-const int shutdown_send = SD_SEND;
-const int shutdown_both = SD_BOTH;
-const int message_peek = MSG_PEEK;
-const int message_out_of_band = MSG_OOB;
-const int message_do_not_route = MSG_DONTROUTE;
-const int message_end_of_record = 0; // Not supported on Windows.
+typedef int signed_size_type;
+# define BOOST_ASIO_OS_DEF(c) BOOST_ASIO_OS_DEF_##c
+# define BOOST_ASIO_OS_DEF_AF_UNSPEC AF_UNSPEC
+# define BOOST_ASIO_OS_DEF_AF_INET AF_INET
+# define BOOST_ASIO_OS_DEF_AF_INET6 AF_INET6
+# define BOOST_ASIO_OS_DEF_SOCK_STREAM SOCK_STREAM
+# define BOOST_ASIO_OS_DEF_SOCK_DGRAM SOCK_DGRAM
+# define BOOST_ASIO_OS_DEF_SOCK_RAW SOCK_RAW
+# define BOOST_ASIO_OS_DEF_SOCK_SEQPACKET SOCK_SEQPACKET
+# define BOOST_ASIO_OS_DEF_IPPROTO_IP IPPROTO_IP
+# define BOOST_ASIO_OS_DEF_IPPROTO_IPV6 IPPROTO_IPV6
+# define BOOST_ASIO_OS_DEF_IPPROTO_TCP IPPROTO_TCP
+# define BOOST_ASIO_OS_DEF_IPPROTO_UDP IPPROTO_UDP
+# define BOOST_ASIO_OS_DEF_IPPROTO_ICMP IPPROTO_ICMP
+# define BOOST_ASIO_OS_DEF_IPPROTO_ICMPV6 IPPROTO_ICMPV6
+# define BOOST_ASIO_OS_DEF_FIONBIO FIONBIO
+# define BOOST_ASIO_OS_DEF_FIONREAD FIONREAD
+# define BOOST_ASIO_OS_DEF_INADDR_ANY INADDR_ANY
+# define BOOST_ASIO_OS_DEF_MSG_OOB MSG_OOB
+# define BOOST_ASIO_OS_DEF_MSG_PEEK MSG_PEEK
+# define BOOST_ASIO_OS_DEF_MSG_DONTROUTE MSG_DONTROUTE
+# define BOOST_ASIO_OS_DEF_MSG_EOR 0 // Not supported on Windows.
+# define BOOST_ASIO_OS_DEF_SHUT_RD SD_RECEIVE
+# define BOOST_ASIO_OS_DEF_SHUT_WR SD_SEND
+# define BOOST_ASIO_OS_DEF_SHUT_RDWR SD_BOTH
+# define BOOST_ASIO_OS_DEF_SOMAXCONN SOMAXCONN
+# define BOOST_ASIO_OS_DEF_SOL_SOCKET SOL_SOCKET
+# define BOOST_ASIO_OS_DEF_SO_BROADCAST SO_BROADCAST
+# define BOOST_ASIO_OS_DEF_SO_DEBUG SO_DEBUG
+# define BOOST_ASIO_OS_DEF_SO_DONTROUTE SO_DONTROUTE
+# define BOOST_ASIO_OS_DEF_SO_KEEPALIVE SO_KEEPALIVE
+# define BOOST_ASIO_OS_DEF_SO_LINGER SO_LINGER
+# define BOOST_ASIO_OS_DEF_SO_SNDBUF SO_SNDBUF
+# define BOOST_ASIO_OS_DEF_SO_RCVBUF SO_RCVBUF
+# define BOOST_ASIO_OS_DEF_SO_SNDLOWAT SO_SNDLOWAT
+# define BOOST_ASIO_OS_DEF_SO_RCVLOWAT SO_RCVLOWAT
+# define BOOST_ASIO_OS_DEF_SO_REUSEADDR SO_REUSEADDR
+# define BOOST_ASIO_OS_DEF_TCP_NODELAY TCP_NODELAY
+# define BOOST_ASIO_OS_DEF_IP_MULTICAST_IF IP_MULTICAST_IF
+# define BOOST_ASIO_OS_DEF_IP_MULTICAST_TTL IP_MULTICAST_TTL
+# define BOOST_ASIO_OS_DEF_IP_MULTICAST_LOOP IP_MULTICAST_LOOP
+# define BOOST_ASIO_OS_DEF_IP_ADD_MEMBERSHIP IP_ADD_MEMBERSHIP
+# define BOOST_ASIO_OS_DEF_IP_DROP_MEMBERSHIP IP_DROP_MEMBERSHIP
+# define BOOST_ASIO_OS_DEF_IP_TTL IP_TTL
+# define BOOST_ASIO_OS_DEF_IPV6_UNICAST_HOPS IPV6_UNICAST_HOPS
+# define BOOST_ASIO_OS_DEF_IPV6_MULTICAST_IF IPV6_MULTICAST_IF
+# define BOOST_ASIO_OS_DEF_IPV6_MULTICAST_HOPS IPV6_MULTICAST_HOPS
+# define BOOST_ASIO_OS_DEF_IPV6_MULTICAST_LOOP IPV6_MULTICAST_LOOP
+# define BOOST_ASIO_OS_DEF_IPV6_JOIN_GROUP IPV6_JOIN_GROUP
+# define BOOST_ASIO_OS_DEF_IPV6_LEAVE_GROUP IPV6_LEAVE_GROUP
+# define BOOST_ASIO_OS_DEF_AI_CANONNAME AI_CANONNAME
+# define BOOST_ASIO_OS_DEF_AI_PASSIVE AI_PASSIVE
+# define BOOST_ASIO_OS_DEF_AI_NUMERICHOST AI_NUMERICHOST
+# if defined(AI_NUMERICSERV)
+#  define BOOST_ASIO_OS_DEF_AI_NUMERICSERV AI_NUMERICSERV
+# else
+#  define BOOST_ASIO_OS_DEF_AI_NUMERICSERV 0
+# endif
+# if defined(AI_V4MAPPED)
+#  define BOOST_ASIO_OS_DEF_AI_V4MAPPED AI_V4MAPPED
+# else
+#  define BOOST_ASIO_OS_DEF_AI_V4MAPPED 0
+# endif
+# if defined(AI_ALL)
+#  define BOOST_ASIO_OS_DEF_AI_ALL AI_ALL
+# else
+#  define BOOST_ASIO_OS_DEF_AI_ALL 0
+# endif
+# if defined(AI_ADDRCONFIG)
+#  define BOOST_ASIO_OS_DEF_AI_ADDRCONFIG AI_ADDRCONFIG
+# else
+#  define BOOST_ASIO_OS_DEF_AI_ADDRCONFIG 0
+# endif
 # if defined (_WIN32_WINNT)
 const int max_iov_len = 64;
 # else
 const int max_iov_len = 16;
 # endif
 #else
@@ -145,22 +300,95 @@ typedef sockaddr_in sockaddr_in4_type;
 typedef in6_addr in6_addr_type;
 typedef ipv6_mreq in6_mreq_type;
 typedef sockaddr_in6 sockaddr_in6_type;
 typedef sockaddr_storage sockaddr_storage_type;
 typedef sockaddr_un sockaddr_un_type;
 typedef addrinfo addrinfo_type;
+typedef ::linger linger_type;
 typedef int ioctl_arg_type;
 typedef uint32_t u_long_type;
 typedef uint16_t u_short_type;
-const int shutdown_receive = SHUT_RD;
-const int shutdown_send = SHUT_WR;
-const int shutdown_both = SHUT_RDWR;
-const int message_peek = MSG_PEEK;
-const int message_out_of_band = MSG_OOB;
-const int message_do_not_route = MSG_DONTROUTE;
-const int message_end_of_record = MSG_EOR;
+#if defined(BOOST_ASIO_HAS_SSIZE_T)
+typedef ssize_t signed_size_type;
+#else // defined(BOOST_ASIO_HAS_SSIZE_T)
+typedef int signed_size_type;
+#endif // defined(BOOST_ASIO_HAS_SSIZE_T)
+# define BOOST_ASIO_OS_DEF(c) BOOST_ASIO_OS_DEF_##c
+# define BOOST_ASIO_OS_DEF_AF_UNSPEC AF_UNSPEC
+# define BOOST_ASIO_OS_DEF_AF_INET AF_INET
+# define BOOST_ASIO_OS_DEF_AF_INET6 AF_INET6
+# define BOOST_ASIO_OS_DEF_SOCK_STREAM SOCK_STREAM
+# define BOOST_ASIO_OS_DEF_SOCK_DGRAM SOCK_DGRAM
+# define BOOST_ASIO_OS_DEF_SOCK_RAW SOCK_RAW
+# define BOOST_ASIO_OS_DEF_SOCK_SEQPACKET SOCK_SEQPACKET
+# define BOOST_ASIO_OS_DEF_IPPROTO_IP IPPROTO_IP
+# define BOOST_ASIO_OS_DEF_IPPROTO_IPV6 IPPROTO_IPV6
+# define BOOST_ASIO_OS_DEF_IPPROTO_TCP IPPROTO_TCP
+# define BOOST_ASIO_OS_DEF_IPPROTO_UDP IPPROTO_UDP
+# define BOOST_ASIO_OS_DEF_IPPROTO_ICMP IPPROTO_ICMP
+# define BOOST_ASIO_OS_DEF_IPPROTO_ICMPV6 IPPROTO_ICMPV6
+# define BOOST_ASIO_OS_DEF_FIONBIO FIONBIO
+# define BOOST_ASIO_OS_DEF_FIONREAD FIONREAD
+# define BOOST_ASIO_OS_DEF_INADDR_ANY INADDR_ANY
+# define BOOST_ASIO_OS_DEF_MSG_OOB MSG_OOB
+# define BOOST_ASIO_OS_DEF_MSG_PEEK MSG_PEEK
+# define BOOST_ASIO_OS_DEF_MSG_DONTROUTE MSG_DONTROUTE
+# define BOOST_ASIO_OS_DEF_MSG_EOR MSG_EOR
+# define BOOST_ASIO_OS_DEF_SHUT_RD SHUT_RD
+# define BOOST_ASIO_OS_DEF_SHUT_WR SHUT_WR
+# define BOOST_ASIO_OS_DEF_SHUT_RDWR SHUT_RDWR
+# define BOOST_ASIO_OS_DEF_SOMAXCONN SOMAXCONN
+# define BOOST_ASIO_OS_DEF_SOL_SOCKET SOL_SOCKET
+# define BOOST_ASIO_OS_DEF_SO_BROADCAST SO_BROADCAST
+# define BOOST_ASIO_OS_DEF_SO_DEBUG SO_DEBUG
+# define BOOST_ASIO_OS_DEF_SO_DONTROUTE SO_DONTROUTE
+# define BOOST_ASIO_OS_DEF_SO_KEEPALIVE SO_KEEPALIVE
+# define BOOST_ASIO_OS_DEF_SO_LINGER SO_LINGER
+# define BOOST_ASIO_OS_DEF_SO_SNDBUF SO_SNDBUF
+# define BOOST_ASIO_OS_DEF_SO_RCVBUF SO_RCVBUF
+# define BOOST_ASIO_OS_DEF_SO_SNDLOWAT SO_SNDLOWAT
+# define BOOST_ASIO_OS_DEF_SO_RCVLOWAT SO_RCVLOWAT
+# define BOOST_ASIO_OS_DEF_SO_REUSEADDR SO_REUSEADDR
+# define BOOST_ASIO_OS_DEF_TCP_NODELAY TCP_NODELAY
+# define BOOST_ASIO_OS_DEF_IP_MULTICAST_IF IP_MULTICAST_IF
+# define BOOST_ASIO_OS_DEF_IP_MULTICAST_TTL IP_MULTICAST_TTL
+# define BOOST_ASIO_OS_DEF_IP_MULTICAST_LOOP IP_MULTICAST_LOOP
+# define BOOST_ASIO_OS_DEF_IP_ADD_MEMBERSHIP IP_ADD_MEMBERSHIP
+# define BOOST_ASIO_OS_DEF_IP_DROP_MEMBERSHIP IP_DROP_MEMBERSHIP
+# define BOOST_ASIO_OS_DEF_IP_TTL IP_TTL
+# define BOOST_ASIO_OS_DEF_IPV6_UNICAST_HOPS IPV6_UNICAST_HOPS
+# define BOOST_ASIO_OS_DEF_IPV6_MULTICAST_IF IPV6_MULTICAST_IF
+# define BOOST_ASIO_OS_DEF_IPV6_MULTICAST_HOPS IPV6_MULTICAST_HOPS
+# define BOOST_ASIO_OS_DEF_IPV6_MULTICAST_LOOP IPV6_MULTICAST_LOOP
+# define BOOST_ASIO_OS_DEF_IPV6_JOIN_GROUP IPV6_JOIN_GROUP
+# define BOOST_ASIO_OS_DEF_IPV6_LEAVE_GROUP IPV6_LEAVE_GROUP
+# define BOOST_ASIO_OS_DEF_AI_CANONNAME AI_CANONNAME
+# define BOOST_ASIO_OS_DEF_AI_PASSIVE AI_PASSIVE
+# define BOOST_ASIO_OS_DEF_AI_NUMERICHOST AI_NUMERICHOST
+# if defined(AI_NUMERICSERV)
+#  define BOOST_ASIO_OS_DEF_AI_NUMERICSERV AI_NUMERICSERV
+# else
+#  define BOOST_ASIO_OS_DEF_AI_NUMERICSERV 0
+# endif
+// Note: QNX Neutrino 6.3 defines AI_V4MAPPED, AI_ALL and AI_ADDRCONFIG but
+// does not implement them. Therefore they are specifically excluded here.
+# if defined(AI_V4MAPPED) && !defined(__QNXNTO__)
+#  define BOOST_ASIO_OS_DEF_AI_V4MAPPED AI_V4MAPPED
+# else
+#  define BOOST_ASIO_OS_DEF_AI_V4MAPPED 0
+# endif
+# if defined(AI_ALL) && !defined(__QNXNTO__)
+#  define BOOST_ASIO_OS_DEF_AI_ALL AI_ALL
+# else
+#  define BOOST_ASIO_OS_DEF_AI_ALL 0
+# endif
+# if defined(AI_ADDRCONFIG) && !defined(__QNXNTO__)
+#  define BOOST_ASIO_OS_DEF_AI_ADDRCONFIG AI_ADDRCONFIG
+# else
+#  define BOOST_ASIO_OS_DEF_AI_ADDRCONFIG 0
+# endif
 # if defined(IOV_MAX)
 const int max_iov_len = IOV_MAX;
 # else
 // POSIX platforms are not required to define IOV_MAX.
 const int max_iov_len = 16;
 # endif
diff --git a/3rdParty/Boost/src/boost/asio/detail/solaris_fenced_block.hpp b/3rdParty/Boost/src/boost/asio/detail/solaris_fenced_block.hpp
index ab6f730..9063bfc 100644
--- a/3rdParty/Boost/src/boost/asio/detail/solaris_fenced_block.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/solaris_fenced_block.hpp
@@ -1,11 +1,11 @@
 //
 // detail/solaris_fenced_block.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_SOLARIS_FENCED_BLOCK_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/static_mutex.hpp b/3rdParty/Boost/src/boost/asio/detail/static_mutex.hpp
index fbac3ed..cc005cb 100644
--- a/3rdParty/Boost/src/boost/asio/detail/static_mutex.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/static_mutex.hpp
@@ -1,11 +1,11 @@
 //
 // detail/static_mutex.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_STATIC_MUTEX_HPP
@@ -14,35 +14,40 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
-#if !defined(BOOST_HAS_THREADS) || defined(BOOST_ASIO_DISABLE_THREADS)
+#if !defined(BOOST_ASIO_HAS_THREADS)
 # include <boost/asio/detail/null_static_mutex.hpp>
-#elif defined(BOOST_WINDOWS)
+#elif defined(BOOST_ASIO_WINDOWS)
 # include <boost/asio/detail/win_static_mutex.hpp>
-#elif defined(BOOST_HAS_PTHREADS)
+#elif defined(BOOST_ASIO_HAS_PTHREADS)
 # include <boost/asio/detail/posix_static_mutex.hpp>
+#elif defined(BOOST_ASIO_HAS_STD_MUTEX_AND_CONDVAR)
+# include <boost/asio/detail/std_static_mutex.hpp>
 #else
 # error Only Windows and POSIX are supported!
 #endif
 
 namespace boost {
 namespace asio {
 namespace detail {
 
-#if !defined(BOOST_HAS_THREADS) || defined(BOOST_ASIO_DISABLE_THREADS)
+#if !defined(BOOST_ASIO_HAS_THREADS)
 typedef null_static_mutex static_mutex;
 # define BOOST_ASIO_STATIC_MUTEX_INIT BOOST_ASIO_NULL_STATIC_MUTEX_INIT
-#elif defined(BOOST_WINDOWS)
+#elif defined(BOOST_ASIO_WINDOWS)
 typedef win_static_mutex static_mutex;
 # define BOOST_ASIO_STATIC_MUTEX_INIT BOOST_ASIO_WIN_STATIC_MUTEX_INIT
-#elif defined(BOOST_HAS_PTHREADS)
+#elif defined(BOOST_ASIO_HAS_PTHREADS)
 typedef posix_static_mutex static_mutex;
 # define BOOST_ASIO_STATIC_MUTEX_INIT BOOST_ASIO_POSIX_STATIC_MUTEX_INIT
+#elif defined(BOOST_ASIO_HAS_STD_MUTEX_AND_CONDVAR)
+typedef std_static_mutex static_mutex;
+# define BOOST_ASIO_STATIC_MUTEX_INIT BOOST_ASIO_STD_STATIC_MUTEX_INIT
 #endif
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
diff --git a/3rdParty/Boost/src/boost/asio/detail/std_event.hpp b/3rdParty/Boost/src/boost/asio/detail/std_event.hpp
new file mode 100644
index 0000000..53390b8
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/detail/std_event.hpp
@@ -0,0 +1,178 @@
+//
+// detail/std_event.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_DETAIL_STD_EVENT_HPP
+#define BOOST_ASIO_DETAIL_STD_EVENT_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HAS_STD_MUTEX_AND_CONDVAR)
+
+#include <chrono>
+#include <condition_variable>
+#include <boost/asio/detail/assert.hpp>
+#include <boost/asio/detail/noncopyable.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+class std_event
+  : private noncopyable
+{
+public:
+  // Constructor.
+  std_event()
+    : state_(0)
+  {
+  }
+
+  // Destructor.
+  ~std_event()
+  {
+  }
+
+  // Signal the event. (Retained for backward compatibility.)
+  template <typename Lock>
+  void signal(Lock& lock)
+  {
+    this->signal_all(lock);
+  }
+
+  // Signal all waiters.
+  template <typename Lock>
+  void signal_all(Lock& lock)
+  {
+    BOOST_ASIO_ASSERT(lock.locked());
+    (void)lock;
+    state_ |= 1;
+    cond_.notify_all();
+  }
+
+  // Unlock the mutex and signal one waiter.
+  template <typename Lock>
+  void unlock_and_signal_one(Lock& lock)
+  {
+    BOOST_ASIO_ASSERT(lock.locked());
+    state_ |= 1;
+    bool have_waiters = (state_ > 1);
+    lock.unlock();
+    if (have_waiters)
+      cond_.notify_one();
+  }
+
+  // If there's a waiter, unlock the mutex and signal it.
+  template <typename Lock>
+  bool maybe_unlock_and_signal_one(Lock& lock)
+  {
+    BOOST_ASIO_ASSERT(lock.locked());
+    state_ |= 1;
+    if (state_ > 1)
+    {
+      lock.unlock();
+      cond_.notify_one();
+      return true;
+    }
+    return false;
+  }
+
+  // Reset the event.
+  template <typename Lock>
+  void clear(Lock& lock)
+  {
+    BOOST_ASIO_ASSERT(lock.locked());
+    (void)lock;
+    state_ &= ~std::size_t(1);
+  }
+
+  // Wait for the event to become signalled.
+  template <typename Lock>
+  void wait(Lock& lock)
+  {
+    BOOST_ASIO_ASSERT(lock.locked());
+    unique_lock_adapter u_lock(lock);
+    while ((state_ & 1) == 0)
+    {
+      waiter w(state_);
+      cond_.wait(u_lock.unique_lock_);
+    }
+  }
+
+  // Timed wait for the event to become signalled.
+  template <typename Lock>
+  bool wait_for_usec(Lock& lock, long usec)
+  {
+    BOOST_ASIO_ASSERT(lock.locked());
+    unique_lock_adapter u_lock(lock);
+    if ((state_ & 1) == 0)
+    {
+      waiter w(state_);
+      cond_.wait_for(u_lock.unique_lock_, std::chrono::microseconds(usec));
+    }
+    return (state_ & 1) != 0;
+  }
+
+private:
+  // Helper class to temporarily adapt a scoped_lock into a unique_lock so that
+  // it can be passed to std::condition_variable::wait().
+  struct unique_lock_adapter
+  {
+    template <typename Lock>
+    explicit unique_lock_adapter(Lock& lock)
+      : unique_lock_(lock.mutex().mutex_, std::adopt_lock)
+    {
+    }
+
+    ~unique_lock_adapter()
+    {
+      unique_lock_.release();
+    }
+
+    std::unique_lock<std::mutex> unique_lock_;
+  };
+
+  // Helper to increment and decrement the state to track outstanding waiters.
+  class waiter
+  {
+  public:
+    explicit waiter(std::size_t& state)
+      : state_(state)
+    {
+      state_ += 2;
+    }
+
+    ~waiter()
+    {
+      state_ -= 2;
+    }
+
+  private:
+    std::size_t& state_;
+  };
+
+  std::condition_variable cond_;
+  std::size_t state_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // defined(BOOST_ASIO_HAS_STD_MUTEX_AND_CONDVAR)
+
+#endif // BOOST_ASIO_DETAIL_STD_EVENT_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/std_mutex.hpp b/3rdParty/Boost/src/boost/asio/detail/std_mutex.hpp
new file mode 100644
index 0000000..58cdc07
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/detail/std_mutex.hpp
@@ -0,0 +1,75 @@
+//
+// detail/std_mutex.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_DETAIL_STD_MUTEX_HPP
+#define BOOST_ASIO_DETAIL_STD_MUTEX_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HAS_STD_MUTEX_AND_CONDVAR)
+
+#include <mutex>
+#include <boost/asio/detail/noncopyable.hpp>
+#include <boost/asio/detail/scoped_lock.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+class std_event;
+
+class std_mutex
+  : private noncopyable
+{
+public:
+  typedef boost::asio::detail::scoped_lock<std_mutex> scoped_lock;
+
+  // Constructor.
+  std_mutex()
+  {
+  }
+
+  // Destructor.
+  ~std_mutex()
+  {
+  }
+
+  // Lock the mutex.
+  void lock()
+  {
+    mutex_.lock();
+  }
+
+  // Unlock the mutex.
+  void unlock()
+  {
+    mutex_.unlock();
+  }
+
+private:
+  friend class std_event;
+  std::mutex mutex_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // defined(BOOST_ASIO_HAS_STD_MUTEX_AND_CONDVAR)
+
+#endif // BOOST_ASIO_DETAIL_STD_MUTEX_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/std_static_mutex.hpp b/3rdParty/Boost/src/boost/asio/detail/std_static_mutex.hpp
new file mode 100644
index 0000000..68980ab
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/detail/std_static_mutex.hpp
@@ -0,0 +1,83 @@
+//
+// detail/std_static_mutex.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_DETAIL_STD_STATIC_MUTEX_HPP
+#define BOOST_ASIO_DETAIL_STD_STATIC_MUTEX_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HAS_STD_MUTEX_AND_CONDVAR)
+
+#include <mutex>
+#include <boost/asio/detail/noncopyable.hpp>
+#include <boost/asio/detail/scoped_lock.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+class std_event;
+
+class std_static_mutex
+  : private noncopyable
+{
+public:
+  typedef boost::asio::detail::scoped_lock<std_static_mutex> scoped_lock;
+
+  // Constructor.
+  std_static_mutex(int)
+  {
+  }
+
+  // Destructor.
+  ~std_static_mutex()
+  {
+  }
+
+  // Initialise the mutex.
+  void init()
+  {
+    // Nothing to do.
+  }
+
+  // Lock the mutex.
+  void lock()
+  {
+    mutex_.lock();
+  }
+
+  // Unlock the mutex.
+  void unlock()
+  {
+    mutex_.unlock();
+  }
+
+private:
+  friend class std_event;
+  std::mutex mutex_;
+};
+
+#define BOOST_ASIO_STD_STATIC_MUTEX_INIT 0
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // defined(BOOST_ASIO_HAS_STD_MUTEX_AND_CONDVAR)
+
+#endif // BOOST_ASIO_DETAIL_STD_STATIC_MUTEX_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/std_thread.hpp b/3rdParty/Boost/src/boost/asio/detail/std_thread.hpp
new file mode 100644
index 0000000..7dcb2fd
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/detail/std_thread.hpp
@@ -0,0 +1,67 @@
+//
+// detail/std_thread.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_DETAIL_STD_THREAD_HPP
+#define BOOST_ASIO_DETAIL_STD_THREAD_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HAS_STD_THREAD)
+
+#include <thread>
+#include <boost/asio/detail/noncopyable.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+class std_thread
+  : private noncopyable
+{
+public:
+  // Constructor.
+  template <typename Function>
+  std_thread(Function f, unsigned int = 0)
+    : thread_(f)
+  {
+  }
+
+  // Destructor.
+  ~std_thread()
+  {
+    join();
+  }
+
+  // Wait for the thread to exit.
+  void join()
+  {
+    if (thread_.joinable())
+      thread_.join();
+  }
+
+private:
+  std::thread thread_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // defined(BOOST_ASIO_HAS_STD_THREAD)
+
+#endif // BOOST_ASIO_DETAIL_STD_THREAD_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/strand_service.hpp b/3rdParty/Boost/src/boost/asio/detail/strand_service.hpp
index 3a271b5..0e1dea8 100644
--- a/3rdParty/Boost/src/boost/asio/detail/strand_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/strand_service.hpp
@@ -1,11 +1,11 @@
 //
 // detail/strand_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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_STRAND_SERVICE_HPP
@@ -83,25 +83,30 @@ public:
 
   // Construct a new strand implementation.
   BOOST_ASIO_DECL void construct(implementation_type& impl);
 
   // Request the io_service to invoke the given handler.
   template <typename Handler>
-  void dispatch(implementation_type& impl, Handler handler);
+  void dispatch(implementation_type& impl, Handler& handler);
 
   // Request the io_service to invoke the given handler and return immediately.
   template <typename Handler>
-  void post(implementation_type& impl, Handler handler);
+  void post(implementation_type& impl, Handler& handler);
+
+  // Determine whether the strand is running in the current thread.
+  BOOST_ASIO_DECL bool running_in_this_thread(
+      const implementation_type& impl) const;
 
 private:
   // Helper function to dispatch a handler. Returns true if the handler should
   // be dispatched immediately.
   BOOST_ASIO_DECL bool do_dispatch(implementation_type& impl, operation* op);
 
   // Helper fiunction to post a handler.
-  BOOST_ASIO_DECL void do_post(implementation_type& impl, operation* op);
+  BOOST_ASIO_DECL void do_post(implementation_type& impl,
+      operation* op, bool is_continuation);
 
   BOOST_ASIO_DECL static void do_complete(io_service_impl* owner,
       operation* base, const boost::system::error_code& ec,
       std::size_t bytes_transferred);
 
   // The io_service implementation used to post completions.
diff --git a/3rdParty/Boost/src/boost/asio/detail/task_io_service.hpp b/3rdParty/Boost/src/boost/asio/detail/task_io_service.hpp
index e05c3a7..a30ea04 100644
--- a/3rdParty/Boost/src/boost/asio/detail/task_io_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/task_io_service.hpp
@@ -1,11 +1,11 @@
 //
 // detail/task_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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_TASK_IO_SERVICE_HPP
@@ -20,24 +20,26 @@
 #if !defined(BOOST_ASIO_HAS_IOCP)
 
 #include <boost/system/error_code.hpp>
 #include <boost/asio/io_service.hpp>
 #include <boost/asio/detail/atomic_count.hpp>
 #include <boost/asio/detail/call_stack.hpp>
+#include <boost/asio/detail/event.hpp>
 #include <boost/asio/detail/mutex.hpp>
 #include <boost/asio/detail/op_queue.hpp>
 #include <boost/asio/detail/reactor_fwd.hpp>
-#include <boost/asio/detail/task_io_service_fwd.hpp>
 #include <boost/asio/detail/task_io_service_operation.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
+struct task_io_service_thread_info;
+
 class task_io_service
   : public boost::asio::detail::service_base<task_io_service>
 {
 public:
   typedef task_io_service_operation operation;
 
@@ -91,75 +93,54 @@ public:
   {
     return thread_call_stack::contains(this) != 0;
   }
 
   // Request invocation of the given handler.
   template <typename Handler>
-  void dispatch(Handler handler);
+  void dispatch(Handler& handler);
 
   // Request invocation of the given handler and return immediately.
   template <typename Handler>
-  void post(Handler handler);
+  void post(Handler& handler);
 
   // Request invocation of the given operation and return immediately. Assumes
   // that work_started() has not yet been called for the operation.
-  BOOST_ASIO_DECL void post_immediate_completion(operation* op);
+  BOOST_ASIO_DECL void post_immediate_completion(
+      operation* op, bool is_continuation);
 
   // Request invocation of the given operation and return immediately. Assumes
   // that work_started() was previously called for the operation.
   BOOST_ASIO_DECL void post_deferred_completion(operation* op);
 
   // Request invocation of the given operations and return immediately. Assumes
   // that work_started() was previously called for each operation.
   BOOST_ASIO_DECL void post_deferred_completions(op_queue<operation>& ops);
 
-  // Request invocation of the given operation, preferring the thread-private
-  // queue if available, and return immediately. Assumes that work_started()
-  // has not yet been called for the operation.
-  BOOST_ASIO_DECL void post_private_immediate_completion(operation* op);
-
-  // Request invocation of the given operation, preferring the thread-private
-  // queue if available, and return immediately. Assumes that work_started()
-  // was previously called for the operation.
-  BOOST_ASIO_DECL void post_private_deferred_completion(operation* op);
-
   // Process unfinished operations as part of a shutdown_service operation.
   // Assumes that work_started() was previously called for the operations.
   BOOST_ASIO_DECL void abandon_operations(op_queue<operation>& ops);
 
 private:
-  // Structure containing information about an idle thread.
-  struct thread_info;
-
-  // Request invocation of the given operation, avoiding the thread-private
-  // queue, and return immediately. Assumes that work_started() has not yet
-  // been called for the operation.
-  BOOST_ASIO_DECL void post_non_private_immediate_completion(operation* op);
+  // Structure containing thread-specific data.
+  typedef task_io_service_thread_info thread_info;
 
-  // Request invocation of the given operation, avoiding the thread-private
-  // queue, and return immediately. Assumes that work_started() was previously
-  // called for the operation.
-  BOOST_ASIO_DECL void post_non_private_deferred_completion(operation* op);
+  // Enqueue the given operation following a failed attempt to dispatch the
+  // operation for immediate invocation.
+  BOOST_ASIO_DECL void do_dispatch(operation* op);
 
   // Run at most one operation. May block.
   BOOST_ASIO_DECL std::size_t do_run_one(mutex::scoped_lock& lock,
       thread_info& this_thread, const boost::system::error_code& ec);
 
   // Poll for at most one operation.
   BOOST_ASIO_DECL std::size_t do_poll_one(mutex::scoped_lock& lock,
       thread_info& this_thread, const boost::system::error_code& ec);
 
   // Stop the task and all idle threads.
   BOOST_ASIO_DECL void stop_all_threads(mutex::scoped_lock& lock);
 
-  // Wakes a single idle thread and unlocks the mutex. Returns true if an idle
-  // thread was found. If there is no idle thread, returns false and leaves the
-  // mutex locked.
-  BOOST_ASIO_DECL bool wake_one_idle_thread_and_unlock(
-      mutex::scoped_lock& lock);
-
   // Wake a single idle thread, or the task, and always unlock the mutex.
   BOOST_ASIO_DECL void wake_one_thread_and_unlock(
       mutex::scoped_lock& lock);
 
   // Helper class to perform task-related operations on block exit.
   struct task_cleanup;
@@ -172,12 +153,15 @@ private:
   // Whether to optimise for single-threaded use cases.
   const bool one_thread_;
 
   // Mutex to protect access to internal data.
   mutable mutex mutex_;
 
+  // Event to wake up blocked threads.
+  event wakeup_event_;
+
   // The task to be run by this service.
   reactor* task_;
 
   // Operation object to represent the position of the task in the queue.
   struct task_operation : operation
   {
@@ -198,15 +182,12 @@ private:
 
   // Flag to indicate that the dispatcher has been shut down.
   bool shutdown_;
 
   // Per-thread call stack to track the state of each thread in the io_service.
   typedef call_stack<task_io_service, thread_info> thread_call_stack;
-
-  // The threads that are currently idle.
-  thread_info* first_idle_thread_;
 };
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
diff --git a/3rdParty/Boost/src/boost/asio/detail/task_io_service_fwd.hpp b/3rdParty/Boost/src/boost/asio/detail/task_io_service_fwd.hpp
deleted file mode 100644
index 4aa0ec3..0000000
--- a/3rdParty/Boost/src/boost/asio/detail/task_io_service_fwd.hpp
+++ /dev/null
@@ -1,28 +0,0 @@
-//
-// detail/task_io_service_fwd.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2012 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_DETAIL_TASK_IO_SERVICE_FWD_HPP
-#define BOOST_ASIO_DETAIL_TASK_IO_SERVICE_FWD_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-namespace boost {
-namespace asio {
-namespace detail {
-
-class task_io_service;
-
-} // namespace detail
-} // namespace asio
-} // namespace boost
-
-#endif // BOOST_ASIO_DETAIL_TASK_IO_SERVICE_FWD_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/task_io_service_operation.hpp b/3rdParty/Boost/src/boost/asio/detail/task_io_service_operation.hpp
index 1bf1301..ea1c85e 100644
--- a/3rdParty/Boost/src/boost/asio/detail/task_io_service_operation.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/task_io_service_operation.hpp
@@ -1,11 +1,11 @@
 //
 // detail/task_io_service_operation.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_TASK_IO_SERVICE_OPERATION_HPP
@@ -15,20 +15,21 @@
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/system/error_code.hpp>
 #include <boost/asio/detail/handler_tracking.hpp>
 #include <boost/asio/detail/op_queue.hpp>
-#include <boost/asio/detail/task_io_service_fwd.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
+class task_io_service;
+
 // Base class for all operations. A function pointer is used instead of virtual
 // functions to avoid the associated overhead.
 class task_io_service_operation BOOST_ASIO_INHERIT_TRACKED_HANDLER
 {
 public:
   void complete(task_io_service& owner,
diff --git a/3rdParty/Boost/src/boost/asio/detail/task_io_service_thread_info.hpp b/3rdParty/Boost/src/boost/asio/detail/task_io_service_thread_info.hpp
new file mode 100644
index 0000000..7165552
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/detail/task_io_service_thread_info.hpp
@@ -0,0 +1,42 @@
+//
+// detail/task_io_service_thread_info.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_DETAIL_TASK_IO_SERVICE_THREAD_INFO_HPP
+#define BOOST_ASIO_DETAIL_TASK_IO_SERVICE_THREAD_INFO_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/op_queue.hpp>
+#include <boost/asio/detail/thread_info_base.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+class task_io_service;
+class task_io_service_operation;
+
+struct task_io_service_thread_info : public thread_info_base
+{
+  op_queue<task_io_service_operation> private_op_queue;
+  long private_outstanding_work;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_TASK_IO_SERVICE_THREAD_INFO_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/thread.hpp b/3rdParty/Boost/src/boost/asio/detail/thread.hpp
index 5b452cf..68755e4 100644
--- a/3rdParty/Boost/src/boost/asio/detail/thread.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/thread.hpp
@@ -1,11 +1,11 @@
 //
 // detail/thread.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_THREAD_HPP
@@ -14,40 +14,44 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
-#if !defined(BOOST_HAS_THREADS) || defined(BOOST_ASIO_DISABLE_THREADS)
+#if !defined(BOOST_ASIO_HAS_THREADS)
 # include <boost/asio/detail/null_thread.hpp>
-#elif defined(BOOST_WINDOWS)
+#elif defined(BOOST_ASIO_WINDOWS)
 # if defined(UNDER_CE)
 #  include <boost/asio/detail/wince_thread.hpp>
 # else
 #  include <boost/asio/detail/win_thread.hpp>
 # endif
-#elif defined(BOOST_HAS_PTHREADS)
+#elif defined(BOOST_ASIO_HAS_PTHREADS)
 # include <boost/asio/detail/posix_thread.hpp>
+#elif defined(BOOST_ASIO_HAS_STD_THREAD)
+# include <boost/asio/detail/std_thread.hpp>
 #else
-# error Only Windows and POSIX are supported!
+# error Only Windows, POSIX and std::thread are supported!
 #endif
 
 namespace boost {
 namespace asio {
 namespace detail {
 
-#if !defined(BOOST_HAS_THREADS) || defined(BOOST_ASIO_DISABLE_THREADS)
+#if !defined(BOOST_ASIO_HAS_THREADS)
 typedef null_thread thread;
-#elif defined(BOOST_WINDOWS)
+#elif defined(BOOST_ASIO_WINDOWS)
 # if defined(UNDER_CE)
 typedef wince_thread thread;
 # else
 typedef win_thread thread;
 # endif
-#elif defined(BOOST_HAS_PTHREADS)
+#elif defined(BOOST_ASIO_HAS_PTHREADS)
 typedef posix_thread thread;
+#elif defined(BOOST_ASIO_HAS_STD_THREAD)
+typedef std_thread thread;
 #endif
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
diff --git a/3rdParty/Boost/src/boost/asio/detail/thread_info_base.hpp b/3rdParty/Boost/src/boost/asio/detail/thread_info_base.hpp
new file mode 100644
index 0000000..9a12e25
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/detail/thread_info_base.hpp
@@ -0,0 +1,93 @@
+//
+// detail/thread_info_base.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_DETAIL_THREAD_INFO_BASE_HPP
+#define BOOST_ASIO_DETAIL_THREAD_INFO_BASE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <climits>
+#include <cstddef>
+#include <boost/asio/detail/noncopyable.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+class thread_info_base
+  : private noncopyable
+{
+public:
+  thread_info_base()
+    : reusable_memory_(0)
+  {
+  }
+
+  ~thread_info_base()
+  {
+    if (reusable_memory_)
+      ::operator delete(reusable_memory_);
+  }
+
+  static void* allocate(thread_info_base* this_thread, std::size_t size)
+  {
+    if (this_thread && this_thread->reusable_memory_)
+    {
+      void* const pointer = this_thread->reusable_memory_;
+      this_thread->reusable_memory_ = 0;
+
+      unsigned char* const mem = static_cast<unsigned char*>(pointer);
+      if (static_cast<std::size_t>(mem[0]) >= size)
+      {
+        mem[size] = mem[0];
+        return pointer;
+      }
+
+      ::operator delete(pointer);
+    }
+
+    void* const pointer = ::operator new(size + 1);
+    unsigned char* const mem = static_cast<unsigned char*>(pointer);
+    mem[size] = (size <= UCHAR_MAX) ? static_cast<unsigned char>(size) : 0;
+    return pointer;
+  }
+
+  static void deallocate(thread_info_base* this_thread,
+      void* pointer, std::size_t size)
+  {
+    if (size <= UCHAR_MAX)
+    {
+      if (this_thread && this_thread->reusable_memory_ == 0)
+      {
+        unsigned char* const mem = static_cast<unsigned char*>(pointer);
+        mem[0] = mem[size];
+        this_thread->reusable_memory_ = pointer;
+        return;
+      }
+    }
+
+    ::operator delete(pointer);
+  }
+
+private:
+  void* reusable_memory_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_THREAD_INFO_BASE_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/throw_error.hpp b/3rdParty/Boost/src/boost/asio/detail/throw_error.hpp
index bfb545a..3ca8b8a 100644
--- a/3rdParty/Boost/src/boost/asio/detail/throw_error.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/throw_error.hpp
@@ -1,11 +1,11 @@
 //
 // detail/throw_error.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_THROW_ERROR_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/throw_exception.hpp b/3rdParty/Boost/src/boost/asio/detail/throw_exception.hpp
new file mode 100644
index 0000000..636e1a2
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/detail/throw_exception.hpp
@@ -0,0 +1,53 @@
+//
+// detail/throw_exception.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_DETAIL_THROW_EXCEPTION_HPP
+#define BOOST_ASIO_DETAIL_THROW_EXCEPTION_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HAS_BOOST_THROW_EXCEPTION)
+# include <boost/throw_exception.hpp>
+#endif // defined(BOOST_ASIO_BOOST_THROW_EXCEPTION)
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+#if defined(BOOST_ASIO_HAS_BOOST_THROW_EXCEPTION)
+using boost::throw_exception;
+#else // defined(BOOST_ASIO_HAS_BOOST_THROW_EXCEPTION)
+
+// Declare the throw_exception function for all targets.
+template <typename Exception>
+void throw_exception(const Exception& e);
+
+// Only define the throw_exception function when exceptions are enabled.
+// Otherwise, it is up to the application to provide a definition of this
+// function.
+# if !defined(BOOST_ASIO_NO_EXCEPTIONS)
+template <typename Exception>
+void throw_exception(const Exception& e)
+{
+  throw e;
+}
+# endif // !defined(BOOST_ASIO_NO_EXCEPTIONS)
+
+#endif // defined(BOOST_ASIO_HAS_BOOST_THROW_EXCEPTION)
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#endif // BOOST_ASIO_DETAIL_THROW_EXCEPTION_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/timer_queue.hpp b/3rdParty/Boost/src/boost/asio/detail/timer_queue.hpp
index d14ba7c..1c94bcd 100644
--- a/3rdParty/Boost/src/boost/asio/detail/timer_queue.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/timer_queue.hpp
@@ -1,11 +1,11 @@
 //
 // detail/timer_queue.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_TIMER_QUEUE_HPP
@@ -15,16 +15,15 @@
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 #include <cstddef>
 #include <vector>
-#include <boost/config.hpp>
-#include <boost/limits.hpp>
-#include <boost/cstdint.hpp>
+#include <boost/asio/detail/cstdint.hpp>
 #include <boost/asio/detail/date_time_fwd.hpp>
+#include <boost/asio/detail/limits.hpp>
 #include <boost/asio/detail/op_queue.hpp>
 #include <boost/asio/detail/timer_queue_base.hpp>
 #include <boost/asio/detail/wait_op.hpp>
 #include <boost/asio/error.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
@@ -285,13 +284,13 @@ private:
   // Helper function to convert a duration into milliseconds.
   template <typename Duration>
   long to_msec(const Duration& d, long max_duration) const
   {
     if (d.ticks() <= 0)
       return 0;
-    boost::int64_t msec = d.total_milliseconds();
+    int64_t msec = d.total_milliseconds();
     if (msec == 0)
       return 1;
     if (msec > max_duration)
       return max_duration;
     return static_cast<long>(msec);
   }
@@ -299,13 +298,13 @@ private:
   // Helper function to convert a duration into microseconds.
   template <typename Duration>
   long to_usec(const Duration& d, long max_duration) const
   {
     if (d.ticks() <= 0)
       return 0;
-    boost::int64_t usec = d.total_microseconds();
+    int64_t usec = d.total_microseconds();
     if (usec == 0)
       return 1;
     if (usec > max_duration)
       return max_duration;
     return static_cast<long>(usec);
   }
diff --git a/3rdParty/Boost/src/boost/asio/detail/timer_queue_base.hpp b/3rdParty/Boost/src/boost/asio/detail/timer_queue_base.hpp
index cc7ef34..44ac90f 100644
--- a/3rdParty/Boost/src/boost/asio/detail/timer_queue_base.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/timer_queue_base.hpp
@@ -1,11 +1,11 @@
 //
 // detail/timer_queue_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)
 //
 // 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_DETAIL_TIMER_QUEUE_BASE_HPP
@@ -55,12 +55,15 @@ private:
   friend class timer_queue_set;
 
   // Next timer queue in the set.
   timer_queue_base* next_;
 };
 
+template <typename Time_Traits>
+class timer_queue;
+
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
diff --git a/3rdParty/Boost/src/boost/asio/detail/timer_queue_fwd.hpp b/3rdParty/Boost/src/boost/asio/detail/timer_queue_fwd.hpp
deleted file mode 100644
index c97753f..0000000
--- a/3rdParty/Boost/src/boost/asio/detail/timer_queue_fwd.hpp
+++ /dev/null
@@ -1,29 +0,0 @@
-//
-// detail/timer_queue_fwd.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2012 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_DETAIL_TIMER_QUEUE_FWD_HPP
-#define BOOST_ASIO_DETAIL_TIMER_QUEUE_FWD_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-namespace boost {
-namespace asio {
-namespace detail {
-
-template <typename Time_Traits>
-class timer_queue;
-
-} // namespace detail
-} // namespace asio
-} // namespace boost
-
-#endif // BOOST_ASIO_DETAIL_TIMER_QUEUE_FWD_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/timer_queue_ptime.hpp b/3rdParty/Boost/src/boost/asio/detail/timer_queue_ptime.hpp
index 4c32ece..9164059 100644
--- a/3rdParty/Boost/src/boost/asio/detail/timer_queue_ptime.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/timer_queue_ptime.hpp
@@ -1,11 +1,11 @@
 //
 // detail/timer_queue_ptime.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_TIMER_QUEUE_PTIME_HPP
@@ -17,12 +17,14 @@
 
 #include <boost/asio/time_traits.hpp>
 #include <boost/asio/detail/timer_queue.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
+#if defined(BOOST_ASIO_HAS_BOOST_DATE_TIME)
+
 namespace boost {
 namespace asio {
 namespace detail {
 
 struct forwarding_posix_time_traits : time_traits<boost::posix_time::ptime> {};
 
@@ -79,12 +81,14 @@ private:
 };
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
+#endif // defined(BOOST_ASIO_HAS_BOOST_DATE_TIME)
+
 #include <boost/asio/detail/pop_options.hpp>
 
 #if defined(BOOST_ASIO_HEADER_ONLY)
 # include <boost/asio/detail/impl/timer_queue_ptime.ipp>
 #endif // defined(BOOST_ASIO_HEADER_ONLY)
 
diff --git a/3rdParty/Boost/src/boost/asio/detail/timer_queue_set.hpp b/3rdParty/Boost/src/boost/asio/detail/timer_queue_set.hpp
index 0289259..e008613 100644
--- a/3rdParty/Boost/src/boost/asio/detail/timer_queue_set.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/timer_queue_set.hpp
@@ -1,11 +1,11 @@
 //
 // detail/timer_queue_set.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_TIMER_QUEUE_SET_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/timer_scheduler.hpp b/3rdParty/Boost/src/boost/asio/detail/timer_scheduler.hpp
index 8feea78..8fdc36f 100644
--- a/3rdParty/Boost/src/boost/asio/detail/timer_scheduler.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/timer_scheduler.hpp
@@ -1,11 +1,11 @@
 //
 // detail/timer_scheduler.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_TIMER_SCHEDULER_HPP
@@ -15,13 +15,15 @@
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 #include <boost/asio/detail/timer_scheduler_fwd.hpp>
 
-#if defined(BOOST_ASIO_HAS_IOCP)
+#if defined(BOOST_ASIO_WINDOWS_RUNTIME)
+# include <boost/asio/detail/winrt_timer_scheduler.hpp>
+#elif defined(BOOST_ASIO_HAS_IOCP)
 # include <boost/asio/detail/win_iocp_io_service.hpp>
 #elif defined(BOOST_ASIO_HAS_EPOLL)
 # include <boost/asio/detail/epoll_reactor.hpp>
 #elif defined(BOOST_ASIO_HAS_KQUEUE)
 # include <boost/asio/detail/kqueue_reactor.hpp>
 #elif defined(BOOST_ASIO_HAS_DEV_POLL)
diff --git a/3rdParty/Boost/src/boost/asio/detail/timer_scheduler_fwd.hpp b/3rdParty/Boost/src/boost/asio/detail/timer_scheduler_fwd.hpp
index a72e256..5bcf249 100644
--- a/3rdParty/Boost/src/boost/asio/detail/timer_scheduler_fwd.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/timer_scheduler_fwd.hpp
@@ -1,11 +1,11 @@
 //
 // detail/timer_scheduler_fwd.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_TIMER_SCHEDULER_FWD_HPP
@@ -14,38 +14,28 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
-#if defined(BOOST_ASIO_HAS_IOCP)
-# include <boost/asio/detail/win_iocp_io_service_fwd.hpp>
-#elif defined(BOOST_ASIO_HAS_EPOLL)
-# include <boost/asio/detail/epoll_reactor_fwd.hpp>
-#elif defined(BOOST_ASIO_HAS_KQUEUE)
-# include <boost/asio/detail/kqueue_reactor_fwd.hpp>
-#elif defined(BOOST_ASIO_HAS_DEV_POLL)
-# include <boost/asio/detail/dev_poll_reactor_fwd.hpp>
-#else
-# include <boost/asio/detail/select_reactor_fwd.hpp>
-#endif
-
 namespace boost {
 namespace asio {
 namespace detail {
 
-#if defined(BOOST_ASIO_HAS_IOCP)
-typedef win_iocp_io_service timer_scheduler;
+#if defined(BOOST_ASIO_WINDOWS_RUNTIME)
+typedef class winrt_timer_scheduler timer_scheduler;
+#elif defined(BOOST_ASIO_HAS_IOCP)
+typedef class win_iocp_io_service timer_scheduler;
 #elif defined(BOOST_ASIO_HAS_EPOLL)
-typedef epoll_reactor timer_scheduler;
+typedef class epoll_reactor timer_scheduler;
 #elif defined(BOOST_ASIO_HAS_KQUEUE)
-typedef kqueue_reactor timer_scheduler;
+typedef class kqueue_reactor timer_scheduler;
 #elif defined(BOOST_ASIO_HAS_DEV_POLL)
-typedef dev_poll_reactor timer_scheduler;
+typedef class dev_poll_reactor timer_scheduler;
 #else
-typedef select_reactor timer_scheduler;
+typedef class select_reactor timer_scheduler;
 #endif
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
diff --git a/3rdParty/Boost/src/boost/asio/detail/tss_ptr.hpp b/3rdParty/Boost/src/boost/asio/detail/tss_ptr.hpp
index d14a959..4b4e766 100644
--- a/3rdParty/Boost/src/boost/asio/detail/tss_ptr.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/tss_ptr.hpp
@@ -1,11 +1,11 @@
 //
 // detail/tss_ptr.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_TSS_PTR_HPP
@@ -14,19 +14,19 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
-#if !defined(BOOST_HAS_THREADS) || defined(BOOST_ASIO_DISABLE_THREADS)
+#if !defined(BOOST_ASIO_HAS_THREADS)
 # include <boost/asio/detail/null_tss_ptr.hpp>
 #elif defined(BOOST_ASIO_HAS_THREAD_KEYWORD_EXTENSION)
 # include <boost/asio/detail/keyword_tss_ptr.hpp>
-#elif defined(BOOST_WINDOWS)
+#elif defined(BOOST_ASIO_WINDOWS)
 # include <boost/asio/detail/win_tss_ptr.hpp>
-#elif defined(BOOST_HAS_PTHREADS)
+#elif defined(BOOST_ASIO_HAS_PTHREADS)
 # include <boost/asio/detail/posix_tss_ptr.hpp>
 #else
 # error Only Windows and POSIX are supported!
 #endif
 
 #include <boost/asio/detail/push_options.hpp>
@@ -34,32 +34,32 @@
 namespace boost {
 namespace asio {
 namespace detail {
 
 template <typename T>
 class tss_ptr
-#if !defined(BOOST_HAS_THREADS) || defined(BOOST_ASIO_DISABLE_THREADS)
+#if !defined(BOOST_ASIO_HAS_THREADS)
   : public null_tss_ptr<T>
 #elif defined(BOOST_ASIO_HAS_THREAD_KEYWORD_EXTENSION)
   : public keyword_tss_ptr<T>
-#elif defined(BOOST_WINDOWS)
+#elif defined(BOOST_ASIO_WINDOWS)
   : public win_tss_ptr<T>
-#elif defined(BOOST_HAS_PTHREADS)
+#elif defined(BOOST_ASIO_HAS_PTHREADS)
   : public posix_tss_ptr<T>
 #endif
 {
 public:
   void operator=(T* value)
   {
-#if !defined(BOOST_HAS_THREADS) || defined(BOOST_ASIO_DISABLE_THREADS)
+#if !defined(BOOST_ASIO_HAS_THREADS)
     null_tss_ptr<T>::operator=(value);
 #elif defined(BOOST_ASIO_HAS_THREAD_KEYWORD_EXTENSION)
     keyword_tss_ptr<T>::operator=(value);
-#elif defined(BOOST_WINDOWS)
+#elif defined(BOOST_ASIO_WINDOWS)
     win_tss_ptr<T>::operator=(value);
-#elif defined(BOOST_HAS_PTHREADS)
+#elif defined(BOOST_ASIO_HAS_PTHREADS)
     posix_tss_ptr<T>::operator=(value);
 #endif
   }
 };
 
 } // namespace detail
diff --git a/3rdParty/Boost/src/boost/asio/detail/type_traits.hpp b/3rdParty/Boost/src/boost/asio/detail/type_traits.hpp
new file mode 100644
index 0000000..67e0404
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/detail/type_traits.hpp
@@ -0,0 +1,60 @@
+//
+// detail/type_traits.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_DETAIL_TYPE_TRAITS_HPP
+#define BOOST_ASIO_DETAIL_TYPE_TRAITS_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HAS_STD_TYPE_TRAITS)
+# include <type_traits>
+#else // defined(BOOST_ASIO_HAS_TYPE_TRAITS)
+# include <boost/type_traits/add_const.hpp>
+# include <boost/type_traits/is_const.hpp>
+# include <boost/type_traits/is_convertible.hpp>
+# include <boost/type_traits/is_function.hpp>
+# include <boost/type_traits/is_same.hpp>
+# include <boost/type_traits/remove_pointer.hpp>
+# include <boost/type_traits/remove_reference.hpp>
+# include <boost/utility/enable_if.hpp>
+#endif // defined(BOOST_ASIO_HAS_TYPE_TRAITS)
+
+namespace boost {
+namespace asio {
+
+#if defined(BOOST_ASIO_HAS_STD_TYPE_TRAITS)
+using std::add_const;
+using std::enable_if;
+using std::is_const;
+using std::is_convertible;
+using std::is_function;
+using std::is_same;
+using std::remove_pointer;
+using std::remove_reference;
+#else // defined(BOOST_ASIO_HAS_STD_TYPE_TRAITS)
+using boost::add_const;
+template <bool Condition, typename Type = void>
+struct enable_if : boost::enable_if_c<Condition, Type> {};
+using boost::is_const;
+using boost::is_convertible;
+using boost::is_function;
+using boost::is_same;
+using boost::remove_pointer;
+using boost::remove_reference;
+#endif // defined(BOOST_ASIO_HAS_STD_TYPE_TRAITS)
+
+} // namespace asio
+} // namespace boost
+
+#endif // BOOST_ASIO_DETAIL_TYPE_TRAITS_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/variadic_templates.hpp b/3rdParty/Boost/src/boost/asio/detail/variadic_templates.hpp
new file mode 100644
index 0000000..b116fe8
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/detail/variadic_templates.hpp
@@ -0,0 +1,63 @@
+//
+// detail/variadic_templates.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_DETAIL_VARIADIC_TEMPLATES_HPP
+#define BOOST_ASIO_DETAIL_VARIADIC_TEMPLATES_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if !defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+# define BOOST_ASIO_VARIADIC_TPARAMS(n) BOOST_ASIO_VARIADIC_TPARAMS_##n
+
+# define BOOST_ASIO_VARIADIC_TPARAMS_1 \
+  typename T1
+# define BOOST_ASIO_VARIADIC_TPARAMS_2 \
+  typename T1, typename T2
+# define BOOST_ASIO_VARIADIC_TPARAMS_3 \
+  typename T1, typename T2, typename T3
+# define BOOST_ASIO_VARIADIC_TPARAMS_4 \
+  typename T1, typename T2, typename T3, typename T4
+# define BOOST_ASIO_VARIADIC_TPARAMS_5 \
+  typename T1, typename T2, typename T3, typename T4, typename T5
+
+# define BOOST_ASIO_VARIADIC_TARGS(n) BOOST_ASIO_VARIADIC_TARGS_##n
+
+# define BOOST_ASIO_VARIADIC_TARGS_1 x1
+# define BOOST_ASIO_VARIADIC_TARGS_2 x1, x2
+# define BOOST_ASIO_VARIADIC_TARGS_3 x1, x2, x3
+# define BOOST_ASIO_VARIADIC_TARGS_4 x1, x2, x3, x4
+# define BOOST_ASIO_VARIADIC_TARGS_5 x1, x2, x3, x4, x5
+
+# define BOOST_ASIO_VARIADIC_PARAMS(n) BOOST_ASIO_VARIADIC_PARAMS_##n
+
+# define BOOST_ASIO_VARIADIC_PARAMS_1 T1 x1
+# define BOOST_ASIO_VARIADIC_PARAMS_2 T1 x1, T2 x2
+# define BOOST_ASIO_VARIADIC_PARAMS_3 T1 x1, T2 x2, T3 x3
+# define BOOST_ASIO_VARIADIC_PARAMS_4 T1 x1, T2 x2, T3 x3, T4 x4
+# define BOOST_ASIO_VARIADIC_PARAMS_5 T1 x1, T2 x2, T3 x3, T4 x4, T5 x5
+
+# define BOOST_ASIO_VARIADIC_ARGS(n) BOOST_ASIO_VARIADIC_ARGS_##n
+
+# define BOOST_ASIO_VARIADIC_ARGS_1 x1
+# define BOOST_ASIO_VARIADIC_ARGS_2 x1, x2
+# define BOOST_ASIO_VARIADIC_ARGS_3 x1, x2, x3
+# define BOOST_ASIO_VARIADIC_ARGS_4 x1, x2, x3, x4
+# define BOOST_ASIO_VARIADIC_ARGS_5 x1, x2, x3, x4, x5
+
+# define BOOST_ASIO_VARIADIC_GENERATE(m) m(1) m(2) m(3) m(4) m(5)
+
+#endif // !defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
+
+#endif // BOOST_ASIO_DETAIL_VARIADIC_TEMPLATES_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/wait_handler.hpp b/3rdParty/Boost/src/boost/asio/detail/wait_handler.hpp
index b511be8..6f2cbc5 100644
--- a/3rdParty/Boost/src/boost/asio/detail/wait_handler.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/wait_handler.hpp
@@ -1,11 +1,11 @@
 //
 // detail/wait_handler.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_WAIT_HANDLER_HPP
@@ -13,12 +13,13 @@
 
 #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/addressof.hpp>
 #include <boost/asio/detail/fenced_block.hpp>
 #include <boost/asio/detail/handler_alloc_helpers.hpp>
 #include <boost/asio/detail/handler_invoke_helpers.hpp>
 #include <boost/asio/detail/wait_op.hpp>
 #include <boost/asio/io_service.hpp>
 
@@ -43,25 +44,25 @@ public:
   static void do_complete(io_service_impl* owner, operation* base,
       const boost::system::error_code& /*ec*/,
       std::size_t /*bytes_transferred*/)
   {
     // Take ownership of the handler object.
     wait_handler* h(static_cast<wait_handler*>(base));
-    ptr p = { boost::addressof(h->handler_), h, h };
+    ptr p = { boost::asio::detail::addressof(h->handler_), h, h };
 
     BOOST_ASIO_HANDLER_COMPLETION((h));
 
     // Make a copy of the handler so that the memory can be deallocated before
     // the upcall is made. Even if we're not about to make an upcall, a
     // sub-object of the handler may be the true owner of the memory associated
     // with the handler. Consequently, a local copy of the handler is required
     // to ensure that any owning sub-object remains valid until after we have
     // deallocated the memory here.
     detail::binder1<Handler, boost::system::error_code>
       handler(h->handler_, h->ec_);
-    p.h = boost::addressof(handler.handler_);
+    p.h = boost::asio::detail::addressof(handler.handler_);
     p.reset();
 
     // Make the upcall if required.
     if (owner)
     {
       fenced_block b(fenced_block::half);
diff --git a/3rdParty/Boost/src/boost/asio/detail/wait_op.hpp b/3rdParty/Boost/src/boost/asio/detail/wait_op.hpp
index 0209eb0..cb6c045 100644
--- a/3rdParty/Boost/src/boost/asio/detail/wait_op.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/wait_op.hpp
@@ -1,11 +1,11 @@
 //
 // detail/wait_op.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_WAIT_OP_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/weak_ptr.hpp b/3rdParty/Boost/src/boost/asio/detail/weak_ptr.hpp
index af9a08d..2604d10 100644
--- a/3rdParty/Boost/src/boost/asio/detail/weak_ptr.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/weak_ptr.hpp
@@ -1,11 +1,11 @@
 //
 // detail/weak_ptr.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_WEAK_PTR_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/win_event.hpp b/3rdParty/Boost/src/boost/asio/detail/win_event.hpp
index 6314048..8ef90c5 100644
--- a/3rdParty/Boost/src/boost/asio/detail/win_event.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/win_event.hpp
@@ -1,11 +1,11 @@
 //
 // detail/win_event.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_WIN_EVENT_HPP
@@ -14,15 +14,15 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
-#if defined(BOOST_WINDOWS)
+#if defined(BOOST_ASIO_WINDOWS)
 
-#include <boost/assert.hpp>
+#include <boost/asio/detail/assert.hpp>
 #include <boost/asio/detail/noncopyable.hpp>
 #include <boost/asio/detail/socket_types.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
@@ -34,65 +34,95 @@ class win_event
 {
 public:
   // Constructor.
   BOOST_ASIO_DECL win_event();
 
   // Destructor.
-  ~win_event()
+  BOOST_ASIO_DECL ~win_event();
+
+  // Signal the event. (Retained for backward compatibility.)
+  template <typename Lock>
+  void signal(Lock& lock)
   {
-    ::CloseHandle(event_);
+    this->signal_all(lock);
   }
 
-  // Signal the event.
+  // Signal all waiters.
   template <typename Lock>
-  void signal(Lock& lock)
+  void signal_all(Lock& lock)
   {
-    BOOST_ASSERT(lock.locked());
+    BOOST_ASIO_ASSERT(lock.locked());
     (void)lock;
-    ::SetEvent(event_);
+    state_ |= 1;
+    ::SetEvent(events_[0]);
   }
 
-  // Signal the event and unlock the mutex.
+  // Unlock the mutex and signal one waiter.
   template <typename Lock>
-  void signal_and_unlock(Lock& lock)
+  void unlock_and_signal_one(Lock& lock)
   {
-    BOOST_ASSERT(lock.locked());
+    BOOST_ASIO_ASSERT(lock.locked());
+    state_ |= 1;
+    bool have_waiters = (state_ > 1);
     lock.unlock();
-    ::SetEvent(event_);
+    if (have_waiters)
+      ::SetEvent(events_[1]);
+  }
+
+  // If there's a waiter, unlock the mutex and signal it.
+  template <typename Lock>
+  bool maybe_unlock_and_signal_one(Lock& lock)
+  {
+    BOOST_ASIO_ASSERT(lock.locked());
+    state_ |= 1;
+    if (state_ > 1)
+    {
+      lock.unlock();
+      ::SetEvent(events_[1]);
+      return true;
+    }
+    return false;
   }
 
   // Reset the event.
   template <typename Lock>
   void clear(Lock& lock)
   {
-    BOOST_ASSERT(lock.locked());
+    BOOST_ASIO_ASSERT(lock.locked());
     (void)lock;
-    ::ResetEvent(event_);
+    ::ResetEvent(events_[0]);
+    state_ &= ~std::size_t(1);
   }
 
   // Wait for the event to become signalled.
   template <typename Lock>
   void wait(Lock& lock)
   {
-    BOOST_ASSERT(lock.locked());
-    lock.unlock();
-    ::WaitForSingleObject(event_, INFINITE);
-    lock.lock();
+    BOOST_ASIO_ASSERT(lock.locked());
+    while ((state_ & 1) == 0)
+    {
+      state_ += 2;
+      lock.unlock();
+      ::WaitForMultipleObjects(2, events_, false, INFINITE);
+      lock.lock();
+      state_ -= 2;
+    }
   }
 
 private:
-  HANDLE event_;
+  HANDLE events_[2];
+  std::size_t state_;
 };
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #if defined(BOOST_ASIO_HEADER_ONLY)
 # include <boost/asio/detail/impl/win_event.ipp>
 #endif // defined(BOOST_ASIO_HEADER_ONLY)
 
-#endif // defined(BOOST_WINDOWS)
+#endif // defined(BOOST_ASIO_WINDOWS)
 
 #endif // BOOST_ASIO_DETAIL_WIN_EVENT_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/win_fd_set_adapter.hpp b/3rdParty/Boost/src/boost/asio/detail/win_fd_set_adapter.hpp
index afb40d0..89f5ffd 100644
--- a/3rdParty/Boost/src/boost/asio/detail/win_fd_set_adapter.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/win_fd_set_adapter.hpp
@@ -1,11 +1,11 @@
 //
 // detail/win_fd_set_adapter.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_WIN_FD_SET_ADAPTER_HPP
@@ -14,15 +14,16 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 
 #include <boost/asio/detail/noncopyable.hpp>
+#include <boost/asio/detail/reactor_op_queue.hpp>
 #include <boost/asio/detail/socket_types.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
@@ -58,32 +59,28 @@ public:
   bool set(socket_type descriptor)
   {
     for (u_int i = 0; i < fd_set_->fd_count; ++i)
       if (fd_set_->fd_array[i] == descriptor)
         return true;
 
-    if (fd_set_->fd_count == capacity_)
-    {
-      u_int new_capacity = capacity_ + capacity_ / 2;
-      win_fd_set* new_fd_set = static_cast<win_fd_set*>(::operator new(
-            sizeof(win_fd_set) - sizeof(SOCKET)
-            + sizeof(SOCKET) * (new_capacity)));
-
-      new_fd_set->fd_count = fd_set_->fd_count;
-      for (u_int i = 0; i < fd_set_->fd_count; ++i)
-        new_fd_set->fd_array[i] = fd_set_->fd_array[i];
-
-      ::operator delete(fd_set_);
-      fd_set_ = new_fd_set;
-      capacity_ = new_capacity;
-    }
-
+    reserve(fd_set_->fd_count + 1);
     fd_set_->fd_array[fd_set_->fd_count++] = descriptor;
     return true;
   }
 
+  void set(reactor_op_queue<socket_type>& operations, op_queue<operation>&)
+  {
+    reactor_op_queue<socket_type>::iterator i = operations.begin();
+    while (i != operations.end())
+    {
+      reactor_op_queue<socket_type>::iterator op_iter = i++;
+      reserve(fd_set_->fd_count + 1);
+      fd_set_->fd_array[fd_set_->fd_count++] = op_iter->first;
+    }
+  }
+
   bool is_set(socket_type descriptor) const
   {
     return !!__WSAFDIsSet(descriptor,
         const_cast<fd_set*>(reinterpret_cast<const fd_set*>(fd_set_)));
   }
 
@@ -94,32 +91,61 @@ public:
 
   socket_type max_descriptor() const
   {
     return max_descriptor_;
   }
 
-private:
+  void perform(reactor_op_queue<socket_type>& operations,
+      op_queue<operation>& ops) const
+  {
+    for (u_int i = 0; i < fd_set_->fd_count; ++i)
+      operations.perform_operations(fd_set_->fd_array[i], ops);
+  }
 
+private:
   // This structure is defined to be compatible with the Windows API fd_set
   // structure, but without being dependent on the value of FD_SETSIZE. We use
   // the "struct hack" to allow the number of descriptors to be varied at
   // runtime.
   struct win_fd_set
   {
     u_int fd_count;
     SOCKET fd_array[1];
   };
 
+  // Increase the fd_set_ capacity to at least the specified number of elements.
+  void reserve(u_int n)
+  {
+    if (n <= capacity_)
+      return;
+
+    u_int new_capacity = capacity_ + capacity_ / 2;
+    if (new_capacity < n)
+      new_capacity = n;
+
+    win_fd_set* new_fd_set = static_cast<win_fd_set*>(::operator new(
+          sizeof(win_fd_set) - sizeof(SOCKET)
+          + sizeof(SOCKET) * (new_capacity)));
+
+    new_fd_set->fd_count = fd_set_->fd_count;
+    for (u_int i = 0; i < fd_set_->fd_count; ++i)
+      new_fd_set->fd_array[i] = fd_set_->fd_array[i];
+
+    ::operator delete(fd_set_);
+    fd_set_ = new_fd_set;
+    capacity_ = new_capacity;
+  }
+
   win_fd_set* fd_set_;
   u_int capacity_;
   socket_type max_descriptor_;
 };
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
-#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 
 #endif // BOOST_ASIO_DETAIL_WIN_FD_SET_ADAPTER_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/win_fenced_block.hpp b/3rdParty/Boost/src/boost/asio/detail/win_fenced_block.hpp
index 5e56aa3..ebe580d 100644
--- a/3rdParty/Boost/src/boost/asio/detail/win_fenced_block.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/win_fenced_block.hpp
@@ -1,11 +1,11 @@
 //
 // detail/win_fenced_block.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_WIN_FENCED_BLOCK_HPP
@@ -14,13 +14,13 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
-#if defined(BOOST_WINDOWS) && !defined(UNDER_CE)
+#if defined(BOOST_ASIO_WINDOWS) && !defined(UNDER_CE)
 
 #include <boost/asio/detail/socket_types.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
@@ -42,13 +42,14 @@ public:
   // Constructor for a full fenced block.
   explicit win_fenced_block(full_t)
   {
 #if defined(__BORLANDC__)
     LONG barrier = 0;
     ::InterlockedExchange(&barrier, 1);
-#elif defined(BOOST_MSVC) && ((BOOST_MSVC < 1400) || !defined(MemoryBarrier))
+#elif defined(BOOST_ASIO_MSVC) \
+  && ((BOOST_ASIO_MSVC < 1400) || !defined(MemoryBarrier))
 # if defined(_M_IX86)
 #  pragma warning(push)
 #  pragma warning(disable:4793)
     LONG barrier;
     __asm { xchg barrier, eax }
 #  pragma warning(pop)
@@ -61,13 +62,14 @@ public:
   // Destructor.
   ~win_fenced_block()
   {
 #if defined(__BORLANDC__)
     LONG barrier = 0;
     ::InterlockedExchange(&barrier, 1);
-#elif defined(BOOST_MSVC) && ((BOOST_MSVC < 1400) || !defined(MemoryBarrier))
+#elif defined(BOOST_ASIO_MSVC) \
+  && ((BOOST_ASIO_MSVC < 1400) || !defined(MemoryBarrier))
 # if defined(_M_IX86)
 #  pragma warning(push)
 #  pragma warning(disable:4793)
     LONG barrier;
     __asm { xchg barrier, eax }
 #  pragma warning(pop)
@@ -81,9 +83,9 @@ public:
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
-#endif // defined(BOOST_WINDOWS) && !defined(UNDER_CE)
+#endif // defined(BOOST_ASIO_WINDOWS) && !defined(UNDER_CE)
 
 #endif // BOOST_ASIO_DETAIL_WIN_FENCED_BLOCK_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/win_iocp_handle_read_op.hpp b/3rdParty/Boost/src/boost/asio/detail/win_iocp_handle_read_op.hpp
index 8b41ab4..a69a291 100644
--- a/3rdParty/Boost/src/boost/asio/detail/win_iocp_handle_read_op.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/win_iocp_handle_read_op.hpp
@@ -1,11 +1,11 @@
 //
 // detail/win_iocp_handle_read_op.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
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 //
 
@@ -18,13 +18,13 @@
 
 #include <boost/asio/detail/config.hpp>
 
 #if defined(BOOST_ASIO_HAS_IOCP)
 
 #include <boost/asio/error.hpp>
-#include <boost/utility/addressof.hpp>
+#include <boost/asio/detail/addressof.hpp>
 #include <boost/asio/detail/bind_handler.hpp>
 #include <boost/asio/detail/buffer_sequence_adapter.hpp>
 #include <boost/asio/detail/fenced_block.hpp>
 #include <boost/asio/detail/handler_alloc_helpers.hpp>
 #include <boost/asio/detail/handler_invoke_helpers.hpp>
 #include <boost/asio/detail/operation.hpp>
@@ -54,13 +54,13 @@ public:
       std::size_t bytes_transferred)
   {
     boost::system::error_code ec(result_ec);
 
     // Take ownership of the operation object.
     win_iocp_handle_read_op* o(static_cast<win_iocp_handle_read_op*>(base));
-    ptr p = { boost::addressof(o->handler_), o, o };
+    ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
 
     BOOST_ASIO_HANDLER_COMPLETION((o));
 
 #if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)
     if (owner)
     {
@@ -79,13 +79,13 @@ public:
     // sub-object of the handler may be the true owner of the memory associated
     // with the handler. Consequently, a local copy of the handler is required
     // to ensure that any owning sub-object remains valid until after we have
     // deallocated the memory here.
     detail::binder2<Handler, boost::system::error_code, std::size_t>
       handler(o->handler_, ec, bytes_transferred);
-    p.h = boost::addressof(handler.handler_);
+    p.h = boost::asio::detail::addressof(handler.handler_);
     p.reset();
 
     // Make the upcall if required.
     if (owner)
     {
       fenced_block b(fenced_block::half);
diff --git a/3rdParty/Boost/src/boost/asio/detail/win_iocp_handle_service.hpp b/3rdParty/Boost/src/boost/asio/detail/win_iocp_handle_service.hpp
index 68a9f90..c769884 100644
--- a/3rdParty/Boost/src/boost/asio/detail/win_iocp_handle_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/win_iocp_handle_service.hpp
@@ -1,11 +1,11 @@
 //
 // detail/win_iocp_handle_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)
 // Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.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)
 //
 
@@ -17,16 +17,17 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
 #if defined(BOOST_ASIO_HAS_IOCP)
 
-#include <boost/cstdint.hpp>
 #include <boost/asio/error.hpp>
 #include <boost/asio/io_service.hpp>
+#include <boost/asio/detail/addressof.hpp>
 #include <boost/asio/detail/buffer_sequence_adapter.hpp>
+#include <boost/asio/detail/cstdint.hpp>
 #include <boost/asio/detail/handler_alloc_helpers.hpp>
 #include <boost/asio/detail/mutex.hpp>
 #include <boost/asio/detail/operation.hpp>
 #include <boost/asio/detail/win_iocp_handle_read_op.hpp>
 #include <boost/asio/detail/win_iocp_handle_write_op.hpp>
 #include <boost/asio/detail/win_iocp_io_service.hpp>
@@ -126,13 +127,13 @@ public:
     return write_some_at(impl, 0, buffers, ec);
   }
 
   // Write the given data at the specified offset. Returns the number of bytes
   // written.
   template <typename ConstBufferSequence>
-  size_t write_some_at(implementation_type& impl, boost::uint64_t offset,
+  size_t write_some_at(implementation_type& impl, uint64_t offset,
       const ConstBufferSequence& buffers, boost::system::error_code& ec)
   {
     boost::asio::const_buffer buffer =
       buffer_sequence_adapter<boost::asio::const_buffer,
         ConstBufferSequence>::first(buffers);
 
@@ -140,17 +141,17 @@ public:
   }
 
   // Start an asynchronous write. The data being written must be valid for the
   // lifetime of the asynchronous operation.
   template <typename ConstBufferSequence, typename Handler>
   void async_write_some(implementation_type& impl,
-      const ConstBufferSequence& buffers, Handler handler)
+      const ConstBufferSequence& buffers, Handler& handler)
   {
     // Allocate and construct an operation to wrap the handler.
     typedef win_iocp_handle_write_op<ConstBufferSequence, Handler> op;
-    typename op::ptr p = { boost::addressof(handler),
+    typename op::ptr p = { boost::asio::detail::addressof(handler),
       boost_asio_handler_alloc_helpers::allocate(
         sizeof(op), handler), 0 };
     p.p = new (p.v) op(buffers, handler);
 
     BOOST_ASIO_HANDLER_CREATION((p.p, "handle", &impl, "async_write_some"));
 
@@ -160,18 +161,18 @@ public:
     p.v = p.p = 0;
   }
 
   // Start an asynchronous write at a specified offset. The data being written
   // must be valid for the lifetime of the asynchronous operation.
   template <typename ConstBufferSequence, typename Handler>
-  void async_write_some_at(implementation_type& impl, boost::uint64_t offset,
-      const ConstBufferSequence& buffers, Handler handler)
+  void async_write_some_at(implementation_type& impl, uint64_t offset,
+      const ConstBufferSequence& buffers, Handler& handler)
   {
     // Allocate and construct an operation to wrap the handler.
     typedef win_iocp_handle_write_op<ConstBufferSequence, Handler> op;
-    typename op::ptr p = { boost::addressof(handler),
+    typename op::ptr p = { boost::asio::detail::addressof(handler),
       boost_asio_handler_alloc_helpers::allocate(
         sizeof(op), handler), 0 };
     p.p = new (p.v) op(buffers, handler);
 
     BOOST_ASIO_HANDLER_CREATION((p.p, "handle", &impl, "async_write_some_at"));
 
@@ -188,13 +189,13 @@ public:
   {
     return read_some_at(impl, 0, buffers, ec);
   }
 
   // Read some data at a specified offset. Returns the number of bytes received.
   template <typename MutableBufferSequence>
-  size_t read_some_at(implementation_type& impl, boost::uint64_t offset,
+  size_t read_some_at(implementation_type& impl, uint64_t offset,
       const MutableBufferSequence& buffers, boost::system::error_code& ec)
   {
     boost::asio::mutable_buffer buffer =
       buffer_sequence_adapter<boost::asio::mutable_buffer,
         MutableBufferSequence>::first(buffers);
 
@@ -202,17 +203,17 @@ public:
   }
 
   // Start an asynchronous read. The buffer for the data being received must be
   // valid for the lifetime of the asynchronous operation.
   template <typename MutableBufferSequence, typename Handler>
   void async_read_some(implementation_type& impl,
-      const MutableBufferSequence& buffers, Handler handler)
+      const MutableBufferSequence& buffers, Handler& handler)
   {
     // Allocate and construct an operation to wrap the handler.
     typedef win_iocp_handle_read_op<MutableBufferSequence, Handler> op;
-    typename op::ptr p = { boost::addressof(handler),
+    typename op::ptr p = { boost::asio::detail::addressof(handler),
       boost_asio_handler_alloc_helpers::allocate(
         sizeof(op), handler), 0 };
     p.p = new (p.v) op(buffers, handler);
 
     BOOST_ASIO_HANDLER_CREATION((p.p, "handle", &impl, "async_read_some"));
 
@@ -223,18 +224,18 @@ public:
   }
 
   // Start an asynchronous read at a specified offset. The buffer for the data
   // being received must be valid for the lifetime of the asynchronous
   // operation.
   template <typename MutableBufferSequence, typename Handler>
-  void async_read_some_at(implementation_type& impl, boost::uint64_t offset,
-      const MutableBufferSequence& buffers, Handler handler)
+  void async_read_some_at(implementation_type& impl, uint64_t offset,
+      const MutableBufferSequence& buffers, Handler& handler)
   {
     // Allocate and construct an operation to wrap the handler.
     typedef win_iocp_handle_read_op<MutableBufferSequence, Handler> op;
-    typename op::ptr p = { boost::addressof(handler),
+    typename op::ptr p = { boost::asio::detail::addressof(handler),
       boost_asio_handler_alloc_helpers::allocate(
         sizeof(op), handler), 0 };
     p.p = new (p.v) op(buffers, handler);
 
     BOOST_ASIO_HANDLER_CREATION((p.p, "handle", &impl, "async_read_some_at"));
 
@@ -245,52 +246,52 @@ public:
   }
 
 private:
   // Prevent the use of the null_buffers type with this service.
   size_t write_some(implementation_type& impl,
       const null_buffers& buffers, boost::system::error_code& ec);
-  size_t write_some_at(implementation_type& impl, boost::uint64_t offset,
+  size_t write_some_at(implementation_type& impl, uint64_t offset,
       const null_buffers& buffers, boost::system::error_code& ec);
   template <typename Handler>
   void async_write_some(implementation_type& impl,
-      const null_buffers& buffers, Handler handler);
+      const null_buffers& buffers, Handler& handler);
   template <typename Handler>
-  void async_write_some_at(implementation_type& impl, boost::uint64_t offset,
-      const null_buffers& buffers, Handler handler);
+  void async_write_some_at(implementation_type& impl, uint64_t offset,
+      const null_buffers& buffers, Handler& handler);
   size_t read_some(implementation_type& impl,
       const null_buffers& buffers, boost::system::error_code& ec);
-  size_t read_some_at(implementation_type& impl, boost::uint64_t offset,
+  size_t read_some_at(implementation_type& impl, uint64_t offset,
       const null_buffers& buffers, boost::system::error_code& ec);
   template <typename Handler>
   void async_read_some(implementation_type& impl,
-      const null_buffers& buffers, Handler handler);
+      const null_buffers& buffers, Handler& handler);
   template <typename Handler>
-  void async_read_some_at(implementation_type& impl, boost::uint64_t offset,
-      const null_buffers& buffers, Handler handler);
+  void async_read_some_at(implementation_type& impl, uint64_t offset,
+      const null_buffers& buffers, Handler& handler);
 
   // Helper class for waiting for synchronous operations to complete.
   class overlapped_wrapper;
 
   // Helper function to perform a synchronous write operation.
   BOOST_ASIO_DECL size_t do_write(implementation_type& impl,
-      boost::uint64_t offset, const boost::asio::const_buffer& buffer,
+      uint64_t offset, const boost::asio::const_buffer& buffer,
       boost::system::error_code& ec);
 
   // Helper function to start a write operation.
   BOOST_ASIO_DECL void start_write_op(implementation_type& impl,
-      boost::uint64_t offset, const boost::asio::const_buffer& buffer,
+      uint64_t offset, const boost::asio::const_buffer& buffer,
       operation* op);
 
   // Helper function to perform a synchronous write operation.
   BOOST_ASIO_DECL size_t do_read(implementation_type& impl,
-      boost::uint64_t offset, const boost::asio::mutable_buffer& buffer,
+      uint64_t offset, const boost::asio::mutable_buffer& buffer,
       boost::system::error_code& ec);
 
   // Helper function to start a read operation.
   BOOST_ASIO_DECL void start_read_op(implementation_type& impl,
-      boost::uint64_t offset, const boost::asio::mutable_buffer& buffer,
+      uint64_t offset, const boost::asio::mutable_buffer& buffer,
       operation* op);
 
   // Update the ID of the thread from which cancellation is safe.
   BOOST_ASIO_DECL void update_cancellation_thread_id(implementation_type& impl);
 
   // Helper function to close a handle when the associated object is being
diff --git a/3rdParty/Boost/src/boost/asio/detail/win_iocp_handle_write_op.hpp b/3rdParty/Boost/src/boost/asio/detail/win_iocp_handle_write_op.hpp
index c87cd60..48af0b7 100644
--- a/3rdParty/Boost/src/boost/asio/detail/win_iocp_handle_write_op.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/win_iocp_handle_write_op.hpp
@@ -1,11 +1,11 @@
 //
 // detail/win_iocp_handle_write_op.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
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 //
 
@@ -18,13 +18,13 @@
 
 #include <boost/asio/detail/config.hpp>
 
 #if defined(BOOST_ASIO_HAS_IOCP)
 
 #include <boost/asio/error.hpp>
-#include <boost/utility/addressof.hpp>
+#include <boost/asio/detail/addressof.hpp>
 #include <boost/asio/detail/bind_handler.hpp>
 #include <boost/asio/detail/buffer_sequence_adapter.hpp>
 #include <boost/asio/detail/fenced_block.hpp>
 #include <boost/asio/detail/handler_alloc_helpers.hpp>
 #include <boost/asio/detail/handler_invoke_helpers.hpp>
 #include <boost/asio/detail/operation.hpp>
@@ -50,13 +50,13 @@ public:
 
   static void do_complete(io_service_impl* owner, operation* base,
       const boost::system::error_code& ec, std::size_t bytes_transferred)
   {
     // Take ownership of the operation object.
     win_iocp_handle_write_op* o(static_cast<win_iocp_handle_write_op*>(base));
-    ptr p = { boost::addressof(o->handler_), o, o };
+    ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
 
     BOOST_ASIO_HANDLER_COMPLETION((o));
 
 #if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)
     if (owner)
     {
@@ -71,13 +71,13 @@ public:
     // sub-object of the handler may be the true owner of the memory associated
     // with the handler. Consequently, a local copy of the handler is required
     // to ensure that any owning sub-object remains valid until after we have
     // deallocated the memory here.
     detail::binder2<Handler, boost::system::error_code, std::size_t>
       handler(o->handler_, ec, bytes_transferred);
-    p.h = boost::addressof(handler.handler_);
+    p.h = boost::asio::detail::addressof(handler.handler_);
     p.reset();
 
     // Make the upcall if required.
     if (owner)
     {
       fenced_block b(fenced_block::half);
diff --git a/3rdParty/Boost/src/boost/asio/detail/win_iocp_io_service.hpp b/3rdParty/Boost/src/boost/asio/detail/win_iocp_io_service.hpp
index 0e3bb0b..215b796 100644
--- a/3rdParty/Boost/src/boost/asio/detail/win_iocp_io_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/win_iocp_io_service.hpp
@@ -1,11 +1,11 @@
 //
 // detail/win_iocp_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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_WIN_IOCP_IO_SERVICE_HPP
@@ -16,26 +16,25 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
 #if defined(BOOST_ASIO_HAS_IOCP)
 
-#include <boost/limits.hpp>
 #include <boost/asio/io_service.hpp>
 #include <boost/asio/detail/call_stack.hpp>
+#include <boost/asio/detail/limits.hpp>
 #include <boost/asio/detail/mutex.hpp>
 #include <boost/asio/detail/op_queue.hpp>
 #include <boost/asio/detail/scoped_ptr.hpp>
 #include <boost/asio/detail/socket_types.hpp>
 #include <boost/asio/detail/thread.hpp>
 #include <boost/asio/detail/timer_queue_base.hpp>
-#include <boost/asio/detail/timer_queue_fwd.hpp>
 #include <boost/asio/detail/timer_queue_set.hpp>
 #include <boost/asio/detail/wait_op.hpp>
-#include <boost/asio/detail/win_iocp_io_service_fwd.hpp>
 #include <boost/asio/detail/win_iocp_operation.hpp>
+#include <boost/asio/detail/win_iocp_thread_info.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
@@ -104,26 +103,26 @@ public:
       stop();
   }
 
   // Return whether a handler can be dispatched immediately.
   bool can_dispatch()
   {
-    return call_stack<win_iocp_io_service>::contains(this) != 0;
+    return thread_call_stack::contains(this) != 0;
   }
 
   // Request invocation of the given handler.
   template <typename Handler>
-  void dispatch(Handler handler);
+  void dispatch(Handler& handler);
 
   // Request invocation of the given handler and return immediately.
   template <typename Handler>
-  void post(Handler handler);
+  void post(Handler& handler);
 
   // Request invocation of the given operation and return immediately. Assumes
   // that work_started() has not yet been called for the operation.
-  void post_immediate_completion(win_iocp_operation* op)
+  void post_immediate_completion(win_iocp_operation* op, bool)
   {
     work_started();
     post_deferred_completion(op);
   }
 
   // Request invocation of the given operation and return immediately. Assumes
@@ -137,13 +136,13 @@ public:
 
   // Request invocation of the given operation using the thread-private queue
   // and return immediately. Assumes that work_started() has not yet been
   // called for the operation.
   void post_private_immediate_completion(win_iocp_operation* op)
   {
-    post_immediate_completion(op);
+    post_immediate_completion(op, false);
   }
 
   // Request invocation of the given operation using the thread-private queue
   // and return immediately. Assumes that work_started() was previously called
   // for the operation.
   void post_private_deferred_completion(win_iocp_operation* op)
@@ -205,12 +204,15 @@ private:
 
   // Dequeues at most one operation from the I/O completion port, and then
   // executes it. Returns the number of operations that were dequeued (i.e.
   // either 0 or 1).
   BOOST_ASIO_DECL size_t do_one(bool block, boost::system::error_code& ec);
 
+  // Helper to calculate the GetQueuedCompletionStatus timeout.
+  BOOST_ASIO_DECL static DWORD get_gqcs_timeout();
+
   // Helper function to add a new timer queue.
   BOOST_ASIO_DECL void do_add_timer_queue(timer_queue_base& queue);
 
   // Helper function to remove a timer queue.
   BOOST_ASIO_DECL void do_remove_timer_queue(timer_queue_base& queue);
 
@@ -234,22 +236,27 @@ private:
   // The count of unfinished work.
   long outstanding_work_;
 
   // Flag to indicate whether the event loop has been stopped.
   mutable long stopped_;
 
+  // Flag to indicate whether there is an in-flight stop event. Every event
+  // posted using PostQueuedCompletionStatus consumes non-paged pool, so to
+  // avoid exhausting this resouce we limit the number of outstanding events.
+  long stop_event_posted_;
+
   // Flag to indicate whether the service has been shut down.
   long shutdown_;
 
   enum
   {
-    // Timeout to use with GetQueuedCompletionStatus. Some versions of windows
-    // have a "bug" where a call to GetQueuedCompletionStatus can appear stuck
-    // even though there are events waiting on the queue. Using a timeout helps
-    // to work around the issue.
-    gqcs_timeout = 500,
+    // Timeout to use with GetQueuedCompletionStatus on older versions of
+    // Windows. Some versions of windows have a "bug" where a call to
+    // GetQueuedCompletionStatus can appear stuck even though there are events
+    // waiting on the queue. Using a timeout helps to work around the issue.
+    default_gqcs_timeout = 500,
 
     // Maximum waitable timer timeout, in milliseconds.
     max_timeout_msec = 5 * 60 * 1000,
 
     // Maximum waitable timer timeout, in microseconds.
     max_timeout_usec = max_timeout_msec * 1000,
@@ -261,12 +268,15 @@ private:
     // Completion key value to indicate that an operation has posted with the
     // original last_error and bytes_transferred values stored in the fields of
     // the OVERLAPPED structure.
     overlapped_contains_result = 2
   };
 
+  // Timeout to use with GetQueuedCompletionStatus.
+  const DWORD gqcs_timeout_;
+
   // Function object for processing timeouts in a background thread.
   struct timer_thread_function;
   friend struct timer_thread_function;
 
   // Background thread used for processing timeouts.
   scoped_ptr<thread> timer_thread_;
@@ -282,12 +292,16 @@ private:
 
   // The timer queues.
   timer_queue_set timer_queues_;
 
   // The operations that are ready to dispatch.
   op_queue<win_iocp_operation> completed_ops_;
+
+  // Per-thread call stack to track the state of each thread in the io_service.
+  typedef call_stack<win_iocp_io_service,
+      win_iocp_thread_info> thread_call_stack;
 };
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
diff --git a/3rdParty/Boost/src/boost/asio/detail/win_iocp_io_service_fwd.hpp b/3rdParty/Boost/src/boost/asio/detail/win_iocp_io_service_fwd.hpp
deleted file mode 100644
index ec31fa1..0000000
--- a/3rdParty/Boost/src/boost/asio/detail/win_iocp_io_service_fwd.hpp
+++ /dev/null
@@ -1,35 +0,0 @@
-//
-// detail/win_iocp_io_service_fwd.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2012 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_DETAIL_WIN_IOCP_IO_SERVICE_FWD_HPP
-#define BOOST_ASIO_DETAIL_WIN_IOCP_IO_SERVICE_FWD_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include <boost/asio/detail/config.hpp>
-
-#if defined(BOOST_ASIO_HAS_IOCP)
-
-namespace boost {
-namespace asio {
-namespace detail {
-
-class win_iocp_io_service;
-class win_iocp_overlapped_ptr;
-
-} // namespace detail
-} // namespace asio
-} // namespace boost
-
-#endif // defined(BOOST_ASIO_HAS_IOCP)
-
-#endif // BOOST_ASIO_DETAIL_WIN_IOCP_IO_SERVICE_FWD_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/win_iocp_null_buffers_op.hpp b/3rdParty/Boost/src/boost/asio/detail/win_iocp_null_buffers_op.hpp
index 021dfdb..ae49f3f 100644
--- a/3rdParty/Boost/src/boost/asio/detail/win_iocp_null_buffers_op.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/win_iocp_null_buffers_op.hpp
@@ -1,11 +1,11 @@
 //
 // detail/win_iocp_null_buffers_op.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_WIN_IOCP_NULL_BUFFERS_OP_HPP
@@ -16,13 +16,13 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
 #if defined(BOOST_ASIO_HAS_IOCP)
 
-#include <boost/utility/addressof.hpp>
+#include <boost/asio/detail/addressof.hpp>
 #include <boost/asio/detail/bind_handler.hpp>
 #include <boost/asio/detail/buffer_sequence_adapter.hpp>
 #include <boost/asio/detail/fenced_block.hpp>
 #include <boost/asio/detail/handler_alloc_helpers.hpp>
 #include <boost/asio/detail/handler_invoke_helpers.hpp>
 #include <boost/asio/detail/reactor_op.hpp>
@@ -60,13 +60,13 @@ public:
       std::size_t bytes_transferred)
   {
     boost::system::error_code ec(result_ec);
 
     // Take ownership of the operation object.
     win_iocp_null_buffers_op* o(static_cast<win_iocp_null_buffers_op*>(base));
-    ptr p = { boost::addressof(o->handler_), o, o };
+    ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
 
     BOOST_ASIO_HANDLER_COMPLETION((o));
 
     // The reactor may have stored a result in the operation object.
     if (o->ec_)
       ec = o->ec_;
@@ -89,13 +89,13 @@ public:
     // sub-object of the handler may be the true owner of the memory associated
     // with the handler. Consequently, a local copy of the handler is required
     // to ensure that any owning sub-object remains valid until after we have
     // deallocated the memory here.
     detail::binder2<Handler, boost::system::error_code, std::size_t>
       handler(o->handler_, ec, bytes_transferred);
-    p.h = boost::addressof(handler.handler_);
+    p.h = boost::asio::detail::addressof(handler.handler_);
     p.reset();
 
     // Make the upcall if required.
     if (owner)
     {
       fenced_block b(fenced_block::half);
diff --git a/3rdParty/Boost/src/boost/asio/detail/win_iocp_operation.hpp b/3rdParty/Boost/src/boost/asio/detail/win_iocp_operation.hpp
index 67b5466..41a58c6 100644
--- a/3rdParty/Boost/src/boost/asio/detail/win_iocp_operation.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/win_iocp_operation.hpp
@@ -1,11 +1,11 @@
 //
 // detail/win_iocp_operation.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_WIN_IOCP_OPERATION_HPP
@@ -19,21 +19,22 @@
 
 #if defined(BOOST_ASIO_HAS_IOCP)
 
 #include <boost/asio/detail/handler_tracking.hpp>
 #include <boost/asio/detail/op_queue.hpp>
 #include <boost/asio/detail/socket_types.hpp>
-#include <boost/asio/detail/win_iocp_io_service_fwd.hpp>
 #include <boost/system/error_code.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
+class win_iocp_io_service;
+
 // Base class for all operations. A function pointer is used instead of virtual
 // functions to avoid the associated overhead.
 class win_iocp_operation
   : public OVERLAPPED
     BOOST_ASIO_ALSO_INHERIT_TRACKED_HANDLER
 {
diff --git a/3rdParty/Boost/src/boost/asio/detail/win_iocp_overlapped_op.hpp b/3rdParty/Boost/src/boost/asio/detail/win_iocp_overlapped_op.hpp
index 235f48e..9a48433 100644
--- a/3rdParty/Boost/src/boost/asio/detail/win_iocp_overlapped_op.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/win_iocp_overlapped_op.hpp
@@ -1,11 +1,11 @@
 //
 // detail/win_iocp_overlapped_op.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_WIN_IOCP_OVERLAPPED_OP_HPP
@@ -17,13 +17,13 @@
 
 #include <boost/asio/detail/config.hpp>
 
 #if defined(BOOST_ASIO_HAS_IOCP)
 
 #include <boost/asio/error.hpp>
-#include <boost/utility/addressof.hpp>
+#include <boost/asio/detail/addressof.hpp>
 #include <boost/asio/detail/bind_handler.hpp>
 #include <boost/asio/detail/fenced_block.hpp>
 #include <boost/asio/detail/handler_alloc_helpers.hpp>
 #include <boost/asio/detail/handler_invoke_helpers.hpp>
 #include <boost/asio/detail/operation.hpp>
 
@@ -47,25 +47,25 @@ public:
 
   static void do_complete(io_service_impl* owner, operation* base,
       const boost::system::error_code& ec, std::size_t bytes_transferred)
   {
     // Take ownership of the operation object.
     win_iocp_overlapped_op* o(static_cast<win_iocp_overlapped_op*>(base));
-    ptr p = { boost::addressof(o->handler_), o, o };
+    ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
 
     BOOST_ASIO_HANDLER_COMPLETION((o));
 
     // Make a copy of the handler so that the memory can be deallocated before
     // the upcall is made. Even if we're not about to make an upcall, a
     // sub-object of the handler may be the true owner of the memory associated
     // with the handler. Consequently, a local copy of the handler is required
     // to ensure that any owning sub-object remains valid until after we have
     // deallocated the memory here.
     detail::binder2<Handler, boost::system::error_code, std::size_t>
       handler(o->handler_, ec, bytes_transferred);
-    p.h = boost::addressof(handler.handler_);
+    p.h = boost::asio::detail::addressof(handler.handler_);
     p.reset();
 
     // Make the upcall if required.
     if (owner)
     {
       fenced_block b(fenced_block::half);
diff --git a/3rdParty/Boost/src/boost/asio/detail/win_iocp_overlapped_ptr.hpp b/3rdParty/Boost/src/boost/asio/detail/win_iocp_overlapped_ptr.hpp
index a6df254..d461e0d 100644
--- a/3rdParty/Boost/src/boost/asio/detail/win_iocp_overlapped_ptr.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/win_iocp_overlapped_ptr.hpp
@@ -1,11 +1,11 @@
 //
 // detail/win_iocp_overlapped_ptr.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_WIN_IOCP_OVERLAPPED_PTR_HPP
@@ -16,14 +16,14 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
 #if defined(BOOST_ASIO_HAS_IOCP)
 
-#include <boost/utility/addressof.hpp>
 #include <boost/asio/io_service.hpp>
+#include <boost/asio/detail/addressof.hpp>
 #include <boost/asio/detail/handler_alloc_helpers.hpp>
 #include <boost/asio/detail/noncopyable.hpp>
 #include <boost/asio/detail/win_iocp_overlapped_op.hpp>
 #include <boost/asio/detail/win_iocp_io_service.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
@@ -75,13 +75,13 @@ public:
   // Reset to contain the specified handler, freeing any current OVERLAPPED
   // object.
   template <typename Handler>
   void reset(boost::asio::io_service& io_service, Handler handler)
   {
     typedef win_iocp_overlapped_op<Handler> op;
-    typename op::ptr p = { boost::addressof(handler),
+    typename op::ptr p = { boost::asio::detail::addressof(handler),
       boost_asio_handler_alloc_helpers::allocate(
         sizeof(op), handler), 0 };
     p.p = new (p.v) op(handler);
 
     BOOST_ASIO_HANDLER_CREATION((p.p, "io_service",
           &io_service.impl_, "overlapped"));
diff --git a/3rdParty/Boost/src/boost/asio/detail/win_iocp_serial_port_service.hpp b/3rdParty/Boost/src/boost/asio/detail/win_iocp_serial_port_service.hpp
index 7d96f6d..a8191ee 100644
--- a/3rdParty/Boost/src/boost/asio/detail/win_iocp_serial_port_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/win_iocp_serial_port_service.hpp
@@ -1,11 +1,11 @@
 //
 // detail/win_iocp_serial_port_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)
 // Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.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)
 //
 
@@ -150,13 +150,13 @@ public:
   }
 
   // Start an asynchronous write. The data being written must be valid for the
   // lifetime of the asynchronous operation.
   template <typename ConstBufferSequence, typename Handler>
   void async_write_some(implementation_type& impl,
-      const ConstBufferSequence& buffers, Handler handler)
+      const ConstBufferSequence& buffers, Handler& handler)
   {
     handle_service_.async_write_some(impl, buffers, handler);
   }
 
   // Read some data. Returns the number of bytes received.
   template <typename MutableBufferSequence>
@@ -167,13 +167,13 @@ public:
   }
 
   // Start an asynchronous read. The buffer for the data being received must be
   // valid for the lifetime of the asynchronous operation.
   template <typename MutableBufferSequence, typename Handler>
   void async_read_some(implementation_type& impl,
-      const MutableBufferSequence& buffers, Handler handler)
+      const MutableBufferSequence& buffers, Handler& handler)
   {
     handle_service_.async_read_some(impl, buffers, handler);
   }
 
 private:
   // Function pointer type for storing a serial port option.
diff --git a/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_accept_op.hpp b/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_accept_op.hpp
index 18db3b4..86684d5 100644
--- a/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_accept_op.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_accept_op.hpp
@@ -1,11 +1,11 @@
 //
 // detail/win_iocp_socket_accept_op.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_WIN_IOCP_SOCKET_ACCEPT_OP_HPP
@@ -16,13 +16,13 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
 #if defined(BOOST_ASIO_HAS_IOCP)
 
-#include <boost/utility/addressof.hpp>
+#include <boost/asio/detail/addressof.hpp>
 #include <boost/asio/detail/bind_handler.hpp>
 #include <boost/asio/detail/buffer_sequence_adapter.hpp>
 #include <boost/asio/detail/fenced_block.hpp>
 #include <boost/asio/detail/handler_alloc_helpers.hpp>
 #include <boost/asio/detail/handler_invoke_helpers.hpp>
 #include <boost/asio/detail/operation.hpp>
@@ -77,13 +77,13 @@ public:
       std::size_t /*bytes_transferred*/)
   {
     boost::system::error_code ec(result_ec);
 
     // Take ownership of the operation object.
     win_iocp_socket_accept_op* o(static_cast<win_iocp_socket_accept_op*>(base));
-    ptr p = { boost::addressof(o->handler_), o, o };
+    ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
 
     if (owner)
     {
       typename Protocol::endpoint peer_endpoint;
       std::size_t addr_len = peer_endpoint.capacity();
       socket_ops::complete_iocp_accept(o->socket_,
@@ -128,13 +128,13 @@ public:
     // sub-object of the handler may be the true owner of the memory associated
     // with the handler. Consequently, a local copy of the handler is required
     // to ensure that any owning sub-object remains valid until after we have
     // deallocated the memory here.
     detail::binder1<Handler, boost::system::error_code>
       handler(o->handler_, ec);
-    p.h = boost::addressof(handler.handler_);
+    p.h = boost::asio::detail::addressof(handler.handler_);
     p.reset();
 
     // Make the upcall if required.
     if (owner)
     {
       fenced_block b(fenced_block::half);
diff --git a/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_connect_op.hpp b/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_connect_op.hpp
new file mode 100644
index 0000000..f940e0a
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_connect_op.hpp
@@ -0,0 +1,126 @@
+//
+// detail/win_iocp_socket_connect_op.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_DETAIL_WIN_IOCP_SOCKET_CONNECT_OP_HPP
+#define BOOST_ASIO_DETAIL_WIN_IOCP_SOCKET_CONNECT_OP_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HAS_IOCP)
+
+#include <boost/asio/detail/addressof.hpp>
+#include <boost/asio/detail/bind_handler.hpp>
+#include <boost/asio/detail/fenced_block.hpp>
+#include <boost/asio/detail/handler_alloc_helpers.hpp>
+#include <boost/asio/detail/handler_invoke_helpers.hpp>
+#include <boost/asio/detail/reactor_op.hpp>
+#include <boost/asio/detail/socket_ops.hpp>
+#include <boost/asio/error.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+class win_iocp_socket_connect_op_base : public reactor_op
+{
+public:
+  win_iocp_socket_connect_op_base(socket_type socket, func_type complete_func)
+    : reactor_op(&win_iocp_socket_connect_op_base::do_perform, complete_func),
+      socket_(socket),
+      connect_ex_(false)
+  {
+  }
+
+  static bool do_perform(reactor_op* base)
+  {
+    win_iocp_socket_connect_op_base* o(
+        static_cast<win_iocp_socket_connect_op_base*>(base));
+
+    return socket_ops::non_blocking_connect(o->socket_, o->ec_);
+  }
+
+  socket_type socket_;
+  bool connect_ex_;
+};
+
+template <typename Handler>
+class win_iocp_socket_connect_op : public win_iocp_socket_connect_op_base
+{
+public:
+  BOOST_ASIO_DEFINE_HANDLER_PTR(win_iocp_socket_connect_op);
+
+  win_iocp_socket_connect_op(socket_type socket, Handler& handler)
+    : win_iocp_socket_connect_op_base(socket,
+        &win_iocp_socket_connect_op::do_complete),
+      handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler))
+  {
+  }
+
+  static void do_complete(io_service_impl* owner, operation* base,
+      const boost::system::error_code& result_ec,
+      std::size_t /*bytes_transferred*/)
+  {
+    boost::system::error_code ec(result_ec);
+
+    // Take ownership of the operation object.
+    win_iocp_socket_connect_op* o(
+        static_cast<win_iocp_socket_connect_op*>(base));
+    ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
+
+    if (owner)
+    {
+      if (o->connect_ex_)
+        socket_ops::complete_iocp_connect(o->socket_, ec);
+      else
+        ec = o->ec_;
+    }
+
+    BOOST_ASIO_HANDLER_COMPLETION((o));
+
+    // Make a copy of the handler so that the memory can be deallocated before
+    // the upcall is made. Even if we're not about to make an upcall, a
+    // sub-object of the handler may be the true owner of the memory associated
+    // with the handler. Consequently, a local copy of the handler is required
+    // to ensure that any owning sub-object remains valid until after we have
+    // deallocated the memory here.
+    detail::binder1<Handler, boost::system::error_code>
+      handler(o->handler_, ec);
+    p.h = boost::asio::detail::addressof(handler.handler_);
+    p.reset();
+
+    // Make the upcall if required.
+    if (owner)
+    {
+      fenced_block b(fenced_block::half);
+      BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_));
+      boost_asio_handler_invoke_helpers::invoke(handler, handler.handler_);
+      BOOST_ASIO_HANDLER_INVOCATION_END;
+    }
+  }
+
+private:
+  Handler handler_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // defined(BOOST_ASIO_HAS_IOCP)
+
+#endif // BOOST_ASIO_DETAIL_WIN_IOCP_SOCKET_CONNECT_OP_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_recv_op.hpp b/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_recv_op.hpp
index b50b742..f7fdcee 100644
--- a/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_recv_op.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_recv_op.hpp
@@ -1,11 +1,11 @@
 //
 // detail/win_iocp_socket_recv_op.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_WIN_IOCP_SOCKET_RECV_OP_HPP
@@ -16,13 +16,13 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
 #if defined(BOOST_ASIO_HAS_IOCP)
 
-#include <boost/utility/addressof.hpp>
+#include <boost/asio/detail/addressof.hpp>
 #include <boost/asio/detail/bind_handler.hpp>
 #include <boost/asio/detail/buffer_sequence_adapter.hpp>
 #include <boost/asio/detail/fenced_block.hpp>
 #include <boost/asio/detail/handler_alloc_helpers.hpp>
 #include <boost/asio/detail/handler_invoke_helpers.hpp>
 #include <boost/asio/detail/operation.hpp>
@@ -57,13 +57,13 @@ public:
       std::size_t bytes_transferred)
   {
     boost::system::error_code ec(result_ec);
 
     // Take ownership of the operation object.
     win_iocp_socket_recv_op* o(static_cast<win_iocp_socket_recv_op*>(base));
-    ptr p = { boost::addressof(o->handler_), o, o };
+    ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
 
     BOOST_ASIO_HANDLER_COMPLETION((o));
 
 #if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)
     // Check whether buffers are still valid.
     if (owner)
@@ -83,13 +83,13 @@ public:
     // sub-object of the handler may be the true owner of the memory associated
     // with the handler. Consequently, a local copy of the handler is required
     // to ensure that any owning sub-object remains valid until after we have
     // deallocated the memory here.
     detail::binder2<Handler, boost::system::error_code, std::size_t>
       handler(o->handler_, ec, bytes_transferred);
-    p.h = boost::addressof(handler.handler_);
+    p.h = boost::asio::detail::addressof(handler.handler_);
     p.reset();
 
     // Make the upcall if required.
     if (owner)
     {
       fenced_block b(fenced_block::half);
diff --git a/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_recvfrom_op.hpp b/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_recvfrom_op.hpp
index 798921d..5e1ade6 100644
--- a/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_recvfrom_op.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_recvfrom_op.hpp
@@ -1,11 +1,11 @@
 //
 // detail/win_iocp_socket_recvfrom_op.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_WIN_IOCP_SOCKET_RECVFROM_OP_HPP
@@ -16,13 +16,13 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
 #if defined(BOOST_ASIO_HAS_IOCP)
 
-#include <boost/utility/addressof.hpp>
+#include <boost/asio/detail/addressof.hpp>
 #include <boost/asio/detail/bind_handler.hpp>
 #include <boost/asio/detail/buffer_sequence_adapter.hpp>
 #include <boost/asio/detail/fenced_block.hpp>
 #include <boost/asio/detail/handler_alloc_helpers.hpp>
 #include <boost/asio/detail/handler_invoke_helpers.hpp>
 #include <boost/asio/detail/operation.hpp>
@@ -64,13 +64,13 @@ public:
   {
     boost::system::error_code ec(result_ec);
 
     // Take ownership of the operation object.
     win_iocp_socket_recvfrom_op* o(
         static_cast<win_iocp_socket_recvfrom_op*>(base));
-    ptr p = { boost::addressof(o->handler_), o, o };
+    ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
 
     BOOST_ASIO_HANDLER_COMPLETION((o));
 
 #if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)
     // Check whether buffers are still valid.
     if (owner)
@@ -90,13 +90,13 @@ public:
     // sub-object of the handler may be the true owner of the memory associated
     // with the handler. Consequently, a local copy of the handler is required
     // to ensure that any owning sub-object remains valid until after we have
     // deallocated the memory here.
     detail::binder2<Handler, boost::system::error_code, std::size_t>
       handler(o->handler_, ec, bytes_transferred);
-    p.h = boost::addressof(handler.handler_);
+    p.h = boost::asio::detail::addressof(handler.handler_);
     p.reset();
 
     // Make the upcall if required.
     if (owner)
     {
       fenced_block b(fenced_block::half);
diff --git a/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_recvmsg_op.hpp b/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_recvmsg_op.hpp
index db13fb8..a09feab 100644
--- a/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_recvmsg_op.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_recvmsg_op.hpp
@@ -1,11 +1,11 @@
 //
 // detail/win_iocp_socket_recvmsg_op.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_WIN_IOCP_SOCKET_RECVMSG_OP_HPP
@@ -16,13 +16,13 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
 #if defined(BOOST_ASIO_HAS_IOCP)
 
-#include <boost/utility/addressof.hpp>
+#include <boost/asio/detail/addressof.hpp>
 #include <boost/asio/detail/bind_handler.hpp>
 #include <boost/asio/detail/buffer_sequence_adapter.hpp>
 #include <boost/asio/detail/fenced_block.hpp>
 #include <boost/asio/detail/handler_alloc_helpers.hpp>
 #include <boost/asio/detail/handler_invoke_helpers.hpp>
 #include <boost/asio/detail/operation.hpp>
@@ -60,13 +60,13 @@ public:
   {
     boost::system::error_code ec(result_ec);
 
     // Take ownership of the operation object.
     win_iocp_socket_recvmsg_op* o(
         static_cast<win_iocp_socket_recvmsg_op*>(base));
-    ptr p = { boost::addressof(o->handler_), o, o };
+    ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
 
     BOOST_ASIO_HANDLER_COMPLETION((o));
 
 #if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)
     // Check whether buffers are still valid.
     if (owner)
@@ -84,13 +84,13 @@ public:
     // sub-object of the handler may be the true owner of the memory associated
     // with the handler. Consequently, a local copy of the handler is required
     // to ensure that any owning sub-object remains valid until after we have
     // deallocated the memory here.
     detail::binder2<Handler, boost::system::error_code, std::size_t>
       handler(o->handler_, ec, bytes_transferred);
-    p.h = boost::addressof(handler.handler_);
+    p.h = boost::asio::detail::addressof(handler.handler_);
     p.reset();
 
     // Make the upcall if required.
     if (owner)
     {
       fenced_block b(fenced_block::half);
diff --git a/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_send_op.hpp b/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_send_op.hpp
index fbd00ca..ef25b88 100644
--- a/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_send_op.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_send_op.hpp
@@ -1,11 +1,11 @@
 //
 // detail/win_iocp_socket_send_op.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_WIN_IOCP_SOCKET_SEND_OP_HPP
@@ -16,13 +16,13 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
 #if defined(BOOST_ASIO_HAS_IOCP)
 
-#include <boost/utility/addressof.hpp>
+#include <boost/asio/detail/addressof.hpp>
 #include <boost/asio/detail/bind_handler.hpp>
 #include <boost/asio/detail/buffer_sequence_adapter.hpp>
 #include <boost/asio/detail/fenced_block.hpp>
 #include <boost/asio/detail/handler_alloc_helpers.hpp>
 #include <boost/asio/detail/handler_invoke_helpers.hpp>
 #include <boost/asio/detail/operation.hpp>
@@ -55,13 +55,13 @@ public:
       std::size_t bytes_transferred)
   {
     boost::system::error_code ec(result_ec);
 
     // Take ownership of the operation object.
     win_iocp_socket_send_op* o(static_cast<win_iocp_socket_send_op*>(base));
-    ptr p = { boost::addressof(o->handler_), o, o };
+    ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
 
     BOOST_ASIO_HANDLER_COMPLETION((o));
 
 #if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)
     // Check whether buffers are still valid.
     if (owner)
@@ -78,13 +78,13 @@ public:
     // sub-object of the handler may be the true owner of the memory associated
     // with the handler. Consequently, a local copy of the handler is required
     // to ensure that any owning sub-object remains valid until after we have
     // deallocated the memory here.
     detail::binder2<Handler, boost::system::error_code, std::size_t>
       handler(o->handler_, ec, bytes_transferred);
-    p.h = boost::addressof(handler.handler_);
+    p.h = boost::asio::detail::addressof(handler.handler_);
     p.reset();
 
     // Make the upcall if required.
     if (owner)
     {
       fenced_block b(fenced_block::half);
diff --git a/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_service.hpp b/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_service.hpp
index d6dc98b..d82e40e 100644
--- a/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_service.hpp
@@ -1,11 +1,11 @@
 //
 // detail/win_iocp_socket_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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_WIN_IOCP_SOCKET_SERVICE_HPP
@@ -17,32 +17,32 @@
 
 #include <boost/asio/detail/config.hpp>
 
 #if defined(BOOST_ASIO_HAS_IOCP)
 
 #include <cstring>
-#include <boost/utility/addressof.hpp>
 #include <boost/asio/error.hpp>
 #include <boost/asio/io_service.hpp>
 #include <boost/asio/socket_base.hpp>
+#include <boost/asio/detail/addressof.hpp>
 #include <boost/asio/detail/bind_handler.hpp>
 #include <boost/asio/detail/buffer_sequence_adapter.hpp>
 #include <boost/asio/detail/fenced_block.hpp>
 #include <boost/asio/detail/handler_alloc_helpers.hpp>
 #include <boost/asio/detail/handler_invoke_helpers.hpp>
 #include <boost/asio/detail/mutex.hpp>
 #include <boost/asio/detail/operation.hpp>
-#include <boost/asio/detail/reactive_socket_connect_op.hpp>
 #include <boost/asio/detail/reactor.hpp>
 #include <boost/asio/detail/reactor_op.hpp>
 #include <boost/asio/detail/socket_holder.hpp>
 #include <boost/asio/detail/socket_ops.hpp>
 #include <boost/asio/detail/socket_types.hpp>
 #include <boost/asio/detail/win_iocp_io_service.hpp>
 #include <boost/asio/detail/win_iocp_null_buffers_op.hpp>
 #include <boost/asio/detail/win_iocp_socket_accept_op.hpp>
+#include <boost/asio/detail/win_iocp_socket_connect_op.hpp>
 #include <boost/asio/detail/win_iocp_socket_recvfrom_op.hpp>
 #include <boost/asio/detail/win_iocp_socket_send_op.hpp>
 #include <boost/asio/detail/win_iocp_socket_service_base.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
@@ -163,12 +163,30 @@ public:
     other_impl.have_remote_endpoint_ = false;
 
     impl.remote_endpoint_ = other_impl.remote_endpoint_;
     other_impl.remote_endpoint_ = endpoint_type();
   }
 
+  // Move-construct a new socket implementation from another protocol type.
+  template <typename Protocol1>
+  void converting_move_construct(implementation_type& impl,
+      typename win_iocp_socket_service<
+        Protocol1>::implementation_type& other_impl)
+  {
+    this->base_move_construct(impl, other_impl);
+
+    impl.protocol_ = protocol_type(other_impl.protocol_);
+    other_impl.protocol_ = typename Protocol1::endpoint().protocol();
+
+    impl.have_remote_endpoint_ = other_impl.have_remote_endpoint_;
+    other_impl.have_remote_endpoint_ = false;
+
+    impl.remote_endpoint_ = other_impl.remote_endpoint_;
+    other_impl.remote_endpoint_ = typename Protocol1::endpoint();
+  }
+
   // Open a new socket implementation.
   boost::system::error_code open(implementation_type& impl,
       const protocol_type& protocol, boost::system::error_code& ec)
   {
     if (!do_open(impl, protocol.family(),
           protocol.type(), protocol.protocol(), ec))
@@ -288,17 +306,17 @@ public:
 
   // Start an asynchronous send. The data being sent must be valid for the
   // lifetime of the asynchronous operation.
   template <typename ConstBufferSequence, typename Handler>
   void async_send_to(implementation_type& impl,
       const ConstBufferSequence& buffers, const endpoint_type& destination,
-      socket_base::message_flags flags, Handler handler)
+      socket_base::message_flags flags, Handler& handler)
   {
     // Allocate and construct an operation to wrap the handler.
     typedef win_iocp_socket_send_op<ConstBufferSequence, Handler> op;
-    typename op::ptr p = { boost::addressof(handler),
+    typename op::ptr p = { boost::asio::detail::addressof(handler),
       boost_asio_handler_alloc_helpers::allocate(
         sizeof(op), handler), 0 };
     p.p = new (p.v) op(impl.cancel_token_, buffers, handler);
 
     BOOST_ASIO_HANDLER_CREATION((p.p, "socket", &impl, "async_send_to"));
 
@@ -311,17 +329,17 @@ public:
     p.v = p.p = 0;
   }
 
   // Start an asynchronous wait until data can be sent without blocking.
   template <typename Handler>
   void async_send_to(implementation_type& impl, const null_buffers&,
-      const endpoint_type&, socket_base::message_flags, Handler handler)
+      const endpoint_type&, socket_base::message_flags, Handler& handler)
   {
     // Allocate and construct an operation to wrap the handler.
     typedef win_iocp_null_buffers_op<Handler> op;
-    typename op::ptr p = { boost::addressof(handler),
+    typename op::ptr p = { boost::asio::detail::addressof(handler),
       boost_asio_handler_alloc_helpers::allocate(
         sizeof(op), handler), 0 };
     p.p = new (p.v) op(impl.cancel_token_, handler);
 
     BOOST_ASIO_HANDLER_CREATION((p.p, "socket",
           &impl, "async_send_to(null_buffers)"));
@@ -369,18 +387,18 @@ public:
   // Start an asynchronous receive. The buffer for the data being received and
   // the sender_endpoint object must both be valid for the lifetime of the
   // asynchronous operation.
   template <typename MutableBufferSequence, typename Handler>
   void async_receive_from(implementation_type& impl,
       const MutableBufferSequence& buffers, endpoint_type& sender_endp,
-      socket_base::message_flags flags, Handler handler)
+      socket_base::message_flags flags, Handler& handler)
   {
     // Allocate and construct an operation to wrap the handler.
     typedef win_iocp_socket_recvfrom_op<
       MutableBufferSequence, endpoint_type, Handler> op;
-    typename op::ptr p = { boost::addressof(handler),
+    typename op::ptr p = { boost::asio::detail::addressof(handler),
       boost_asio_handler_alloc_helpers::allocate(
         sizeof(op), handler), 0 };
     p.p = new (p.v) op(sender_endp, impl.cancel_token_, buffers, handler);
 
     BOOST_ASIO_HANDLER_CREATION((p.p, "socket", &impl, "async_receive_from"));
 
@@ -393,17 +411,17 @@ public:
   }
 
   // Wait until data can be received without blocking.
   template <typename Handler>
   void async_receive_from(implementation_type& impl,
       const null_buffers&, endpoint_type& sender_endpoint,
-      socket_base::message_flags flags, Handler handler)
+      socket_base::message_flags flags, Handler& handler)
   {
     // Allocate and construct an operation to wrap the handler.
     typedef win_iocp_null_buffers_op<Handler> op;
-    typename op::ptr p = { boost::addressof(handler),
+    typename op::ptr p = { boost::asio::detail::addressof(handler),
       boost_asio_handler_alloc_helpers::allocate(
         sizeof(op), handler), 0 };
     p.p = new (p.v) op(impl.cancel_token_, handler);
 
     BOOST_ASIO_HANDLER_CREATION((p.p, "socket", &impl,
           "async_receive_from(null_buffers)"));
@@ -430,13 +448,13 @@ public:
     std::size_t addr_len = peer_endpoint ? peer_endpoint->capacity() : 0;
     socket_holder new_socket(socket_ops::sync_accept(impl.socket_,
           impl.state_, peer_endpoint ? peer_endpoint->data() : 0,
           peer_endpoint ? &addr_len : 0, ec));
 
     // On success, assign new connection to peer socket object.
-    if (new_socket.get() >= 0)
+    if (new_socket.get() != invalid_socket)
     {
       if (peer_endpoint)
         peer_endpoint->resize(addr_len);
       if (!peer.assign(impl.protocol_, new_socket.get(), ec))
         new_socket.release();
     }
@@ -445,17 +463,17 @@ public:
   }
 
   // Start an asynchronous accept. The peer and peer_endpoint objects
   // must be valid until the accept's handler is invoked.
   template <typename Socket, typename Handler>
   void async_accept(implementation_type& impl, Socket& peer,
-      endpoint_type* peer_endpoint, Handler handler)
+      endpoint_type* peer_endpoint, Handler& handler)
   {
     // Allocate and construct an operation to wrap the handler.
     typedef win_iocp_socket_accept_op<Socket, protocol_type, Handler> op;
-    typename op::ptr p = { boost::addressof(handler),
+    typename op::ptr p = { boost::asio::detail::addressof(handler),
       boost_asio_handler_alloc_helpers::allocate(
         sizeof(op), handler), 0 };
     bool enable_connection_aborted =
       (impl.state_ & socket_ops::enable_connection_aborted) != 0;
     p.p = new (p.v) op(*this, impl.socket_, peer, impl.protocol_,
         peer_endpoint, enable_connection_aborted, handler);
@@ -478,25 +496,25 @@ public:
     return ec;
   }
 
   // Start an asynchronous connect.
   template <typename Handler>
   void async_connect(implementation_type& impl,
-      const endpoint_type& peer_endpoint, Handler handler)
+      const endpoint_type& peer_endpoint, Handler& handler)
   {
     // Allocate and construct an operation to wrap the handler.
-    typedef reactive_socket_connect_op<Handler> op;
-    typename op::ptr p = { boost::addressof(handler),
+    typedef win_iocp_socket_connect_op<Handler> op;
+    typename op::ptr p = { boost::asio::detail::addressof(handler),
       boost_asio_handler_alloc_helpers::allocate(
         sizeof(op), handler), 0 };
     p.p = new (p.v) op(impl.socket_, handler);
 
     BOOST_ASIO_HANDLER_CREATION((p.p, "socket", &impl, "async_connect"));
 
-    start_connect_op(impl, p.p, peer_endpoint.data(),
-        static_cast<int>(peer_endpoint.size()));
+    start_connect_op(impl, impl.protocol_.family(), impl.protocol_.type(),
+        peer_endpoint.data(), static_cast<int>(peer_endpoint.size()), p.p);
     p.v = p.p = 0;
   }
 };
 
 } // namespace detail
 } // namespace asio
diff --git a/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_service_base.hpp b/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_service_base.hpp
index 79580de..f5f0223 100644
--- a/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_service_base.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_service_base.hpp
@@ -1,11 +1,11 @@
 //
 // detail/win_iocp_socket_service_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)
 //
 // 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_DETAIL_WIN_IOCP_SOCKET_SERVICE_BASE_HPP
@@ -16,17 +16,16 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
 #if defined(BOOST_ASIO_HAS_IOCP)
 
-#include <boost/type_traits/is_same.hpp>
-#include <boost/utility/addressof.hpp>
 #include <boost/asio/error.hpp>
 #include <boost/asio/io_service.hpp>
 #include <boost/asio/socket_base.hpp>
+#include <boost/asio/detail/addressof.hpp>
 #include <boost/asio/detail/bind_handler.hpp>
 #include <boost/asio/detail/buffer_sequence_adapter.hpp>
 #include <boost/asio/detail/fenced_block.hpp>
 #include <boost/asio/detail/handler_alloc_helpers.hpp>
 #include <boost/asio/detail/handler_invoke_helpers.hpp>
 #include <boost/asio/detail/mutex.hpp>
@@ -35,12 +34,13 @@
 #include <boost/asio/detail/reactor_op.hpp>
 #include <boost/asio/detail/socket_holder.hpp>
 #include <boost/asio/detail/socket_ops.hpp>
 #include <boost/asio/detail/socket_types.hpp>
 #include <boost/asio/detail/win_iocp_io_service.hpp>
 #include <boost/asio/detail/win_iocp_null_buffers_op.hpp>
+#include <boost/asio/detail/win_iocp_socket_connect_op.hpp>
 #include <boost/asio/detail/win_iocp_socket_send_op.hpp>
 #include <boost/asio/detail/win_iocp_socket_recv_op.hpp>
 #include <boost/asio/detail/win_iocp_socket_recvmsg_op.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
@@ -213,17 +213,17 @@ public:
 
   // Start an asynchronous send. The data being sent must be valid for the
   // lifetime of the asynchronous operation.
   template <typename ConstBufferSequence, typename Handler>
   void async_send(base_implementation_type& impl,
       const ConstBufferSequence& buffers,
-      socket_base::message_flags flags, Handler handler)
+      socket_base::message_flags flags, Handler& handler)
   {
     // Allocate and construct an operation to wrap the handler.
     typedef win_iocp_socket_send_op<ConstBufferSequence, Handler> op;
-    typename op::ptr p = { boost::addressof(handler),
+    typename op::ptr p = { boost::asio::detail::addressof(handler),
       boost_asio_handler_alloc_helpers::allocate(
         sizeof(op), handler), 0 };
     p.p = new (p.v) op(impl.cancel_token_, buffers, handler);
 
     BOOST_ASIO_HANDLER_CREATION((p.p, "socket", &impl, "async_send"));
 
@@ -236,17 +236,17 @@ public:
     p.v = p.p = 0;
   }
 
   // Start an asynchronous wait until data can be sent without blocking.
   template <typename Handler>
   void async_send(base_implementation_type& impl, const null_buffers&,
-      socket_base::message_flags, Handler handler)
+      socket_base::message_flags, Handler& handler)
   {
     // Allocate and construct an operation to wrap the handler.
     typedef win_iocp_null_buffers_op<Handler> op;
-    typename op::ptr p = { boost::addressof(handler),
+    typename op::ptr p = { boost::asio::detail::addressof(handler),
       boost_asio_handler_alloc_helpers::allocate(
         sizeof(op), handler), 0 };
     p.p = new (p.v) op(impl.cancel_token_, handler);
 
     BOOST_ASIO_HANDLER_CREATION((p.p, "socket",
           &impl, "async_send(null_buffers)"));
@@ -280,17 +280,17 @@ public:
 
   // Start an asynchronous receive. The buffer for the data being received
   // must be valid for the lifetime of the asynchronous operation.
   template <typename MutableBufferSequence, typename Handler>
   void async_receive(base_implementation_type& impl,
       const MutableBufferSequence& buffers,
-      socket_base::message_flags flags, Handler handler)
+      socket_base::message_flags flags, Handler& handler)
   {
     // Allocate and construct an operation to wrap the handler.
     typedef win_iocp_socket_recv_op<MutableBufferSequence, Handler> op;
-    typename op::ptr p = { boost::addressof(handler),
+    typename op::ptr p = { boost::asio::detail::addressof(handler),
       boost_asio_handler_alloc_helpers::allocate(
         sizeof(op), handler), 0 };
     p.p = new (p.v) op(impl.state_, impl.cancel_token_, buffers, handler);
 
     BOOST_ASIO_HANDLER_CREATION((p.p, "socket", &impl, "async_receive"));
 
@@ -303,17 +303,17 @@ public:
     p.v = p.p = 0;
   }
 
   // Wait until data can be received without blocking.
   template <typename Handler>
   void async_receive(base_implementation_type& impl, const null_buffers&,
-      socket_base::message_flags flags, Handler handler)
+      socket_base::message_flags flags, Handler& handler)
   {
     // Allocate and construct an operation to wrap the handler.
     typedef win_iocp_null_buffers_op<Handler> op;
-    typename op::ptr p = { boost::addressof(handler),
+    typename op::ptr p = { boost::asio::detail::addressof(handler),
       boost_asio_handler_alloc_helpers::allocate(
         sizeof(op), handler), 0 };
     p.p = new (p.v) op(impl.cancel_token_, handler);
 
     BOOST_ASIO_HANDLER_CREATION((p.p, "socket",
           &impl, "async_receive(null_buffers)"));
@@ -354,17 +354,17 @@ public:
 
   // Start an asynchronous receive. The buffer for the data being received
   // must be valid for the lifetime of the asynchronous operation.
   template <typename MutableBufferSequence, typename Handler>
   void async_receive_with_flags(base_implementation_type& impl,
       const MutableBufferSequence& buffers, socket_base::message_flags in_flags,
-      socket_base::message_flags& out_flags, Handler handler)
+      socket_base::message_flags& out_flags, Handler& handler)
   {
     // Allocate and construct an operation to wrap the handler.
     typedef win_iocp_socket_recvmsg_op<MutableBufferSequence, Handler> op;
-    typename op::ptr p = { boost::addressof(handler),
+    typename op::ptr p = { boost::asio::detail::addressof(handler),
       boost_asio_handler_alloc_helpers::allocate(
         sizeof(op), handler), 0 };
     p.p = new (p.v) op(impl.cancel_token_, buffers, out_flags, handler);
 
     BOOST_ASIO_HANDLER_CREATION((p.p, "socket",
           &impl, "async_receive_with_flags"));
@@ -377,17 +377,17 @@ public:
   }
 
   // Wait until data can be received without blocking.
   template <typename Handler>
   void async_receive_with_flags(base_implementation_type& impl,
       const null_buffers&, socket_base::message_flags in_flags,
-      socket_base::message_flags& out_flags, Handler handler)
+      socket_base::message_flags& out_flags, Handler& handler)
   {
     // Allocate and construct an operation to wrap the handler.
     typedef win_iocp_null_buffers_op<Handler> op;
-    typename op::ptr p = { boost::addressof(handler),
+    typename op::ptr p = { boost::asio::detail::addressof(handler),
       boost_asio_handler_alloc_helpers::allocate(
         sizeof(op), handler), 0 };
     p.p = new (p.v) op(impl.cancel_token_, handler);
 
     BOOST_ASIO_HANDLER_CREATION((p.p, "socket", &impl,
           "async_receive_with_flags(null_buffers)"));
@@ -443,19 +443,20 @@ protected:
 
   // Helper function to start an asynchronous accept operation.
   BOOST_ASIO_DECL void start_accept_op(base_implementation_type& impl,
       bool peer_is_open, socket_holder& new_socket, int family, int type,
       int protocol, void* output_buffer, DWORD address_length, operation* op);
 
-  // Start an asynchronous read or write operation using the the reactor.
+  // Start an asynchronous read or write operation using the reactor.
   BOOST_ASIO_DECL void start_reactor_op(base_implementation_type& impl,
       int op_type, reactor_op* op);
 
   // Start the asynchronous connect operation using the reactor.
   BOOST_ASIO_DECL void start_connect_op(base_implementation_type& impl,
-      reactor_op* op, const socket_addr_type* addr, std::size_t addrlen);
+      int family, int type, const socket_addr_type* remote_addr,
+      std::size_t remote_addrlen, win_iocp_socket_connect_op_base* op);
 
   // Helper function to close a socket when the associated object is being
   // destroyed.
   BOOST_ASIO_DECL void close_for_destruction(base_implementation_type& impl);
 
   // Update the ID of the thread from which cancellation is safe.
@@ -464,12 +465,22 @@ protected:
 
   // Helper function to get the reactor. If no reactor has been created yet, a
   // new one is obtained from the io_service and a pointer to it is cached in
   // this service.
   BOOST_ASIO_DECL reactor& get_reactor();
 
+  // The type of a ConnectEx function pointer, as old SDKs may not provide it.
+  typedef BOOL (PASCAL *connect_ex_fn)(SOCKET,
+      const socket_addr_type*, int, void*, DWORD, DWORD*, OVERLAPPED*);
+
+  // Helper function to get the ConnectEx pointer. If no ConnectEx pointer has
+  // been obtained yet, one is obtained using WSAIoctl and the pointer is
+  // cached. Returns a null pointer if ConnectEx is not available.
+  BOOST_ASIO_DECL connect_ex_fn get_connect_ex(
+      base_implementation_type& impl, int type);
+
   // Helper function to emulate InterlockedCompareExchangePointer functionality
   // for:
   // - very old Platform SDKs; and
   // - platform SDKs where MSVC's /Wp64 option causes spurious warnings.
   BOOST_ASIO_DECL void* interlocked_compare_exchange_pointer(
       void** dest, void* exch, void* cmp);
@@ -487,12 +498,15 @@ protected:
   win_iocp_io_service& iocp_service_;
 
   // The reactor used for performing connect operations. This object is created
   // only if needed.
   reactor* reactor_;
 
+  // Pointer to ConnectEx implementation.
+  void* connect_ex_;
+
   // Mutex to protect access to the linked list of implementations. 
   boost::asio::detail::mutex mutex_;
 
   // The head of a linked list of all implementations.
   base_implementation_type* impl_list_;
 };
diff --git a/3rdParty/Boost/src/boost/asio/detail/win_iocp_thread_info.hpp b/3rdParty/Boost/src/boost/asio/detail/win_iocp_thread_info.hpp
new file mode 100644
index 0000000..c036d39
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/detail/win_iocp_thread_info.hpp
@@ -0,0 +1,36 @@
+//
+// detail/win_iocp_thread_info.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_DETAIL_WIN_IOCP_THREAD_INFO_HPP
+#define BOOST_ASIO_DETAIL_WIN_IOCP_THREAD_INFO_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/thread_info_base.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+struct win_iocp_thread_info : public thread_info_base
+{
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_WIN_IOCP_THREAD_INFO_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/win_mutex.hpp b/3rdParty/Boost/src/boost/asio/detail/win_mutex.hpp
index 930d01f..2f927b3 100644
--- a/3rdParty/Boost/src/boost/asio/detail/win_mutex.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/win_mutex.hpp
@@ -1,11 +1,11 @@
 //
 // detail/win_mutex.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_WIN_MUTEX_HPP
@@ -14,13 +14,13 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
-#if defined(BOOST_WINDOWS)
+#if defined(BOOST_ASIO_WINDOWS)
 
 #include <boost/asio/detail/noncopyable.hpp>
 #include <boost/asio/detail/scoped_lock.hpp>
 #include <boost/asio/detail/socket_types.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
@@ -72,9 +72,9 @@ private:
 #include <boost/asio/detail/pop_options.hpp>
 
 #if defined(BOOST_ASIO_HEADER_ONLY)
 # include <boost/asio/detail/impl/win_mutex.ipp>
 #endif // defined(BOOST_ASIO_HEADER_ONLY)
 
-#endif // defined(BOOST_WINDOWS)
+#endif // defined(BOOST_ASIO_WINDOWS)
 
 #endif // BOOST_ASIO_DETAIL_WIN_MUTEX_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/win_object_handle_service.hpp b/3rdParty/Boost/src/boost/asio/detail/win_object_handle_service.hpp
index 52a972d..a9169ca 100644
--- a/3rdParty/Boost/src/boost/asio/detail/win_object_handle_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/win_object_handle_service.hpp
@@ -1,11 +1,11 @@
 //
 // detail/win_object_handle_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)
 // Copyright (c) 2011 Boris Schaeling (boris@highscore.de)
 //
 // 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)
 //
 
@@ -17,13 +17,13 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
 #if defined(BOOST_ASIO_HAS_WINDOWS_OBJECT_HANDLE)
 
-#include <boost/utility/addressof.hpp>
+#include <boost/asio/detail/addressof.hpp>
 #include <boost/asio/detail/handler_alloc_helpers.hpp>
 #include <boost/asio/detail/wait_handler.hpp>
 #include <boost/asio/error.hpp>
 #include <boost/asio/io_service.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
@@ -127,17 +127,17 @@ public:
   // Perform a synchronous wait for the object to enter a signalled state.
   BOOST_ASIO_DECL void wait(implementation_type& impl,
       boost::system::error_code& ec);
 
   /// Start an asynchronous wait.
   template <typename Handler>
-  void async_wait(implementation_type& impl, Handler handler)
+  void async_wait(implementation_type& impl, Handler& handler)
   {
     // Allocate and construct an operation to wrap the handler.
     typedef wait_handler<Handler> op;
-    typename op::ptr p = { boost::addressof(handler),
+    typename op::ptr p = { boost::asio::detail::addressof(handler),
       boost_asio_handler_alloc_helpers::allocate(
         sizeof(op), handler), 0 };
     p.p = new (p.v) op(handler);
 
     BOOST_ASIO_HANDLER_CREATION((p.p, "object_handle", &impl, "async_wait"));
 
diff --git a/3rdParty/Boost/src/boost/asio/detail/win_static_mutex.hpp b/3rdParty/Boost/src/boost/asio/detail/win_static_mutex.hpp
index a54b36b..a6a7e11 100644
--- a/3rdParty/Boost/src/boost/asio/detail/win_static_mutex.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/win_static_mutex.hpp
@@ -1,11 +1,11 @@
 //
 // detail/win_static_mutex.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_WIN_STATIC_MUTEX_HPP
@@ -14,13 +14,13 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
-#if defined(BOOST_WINDOWS)
+#if defined(BOOST_ASIO_WINDOWS)
 
 #include <boost/asio/detail/scoped_lock.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
@@ -68,9 +68,9 @@ struct win_static_mutex
 #include <boost/asio/detail/pop_options.hpp>
 
 #if defined(BOOST_ASIO_HEADER_ONLY)
 # include <boost/asio/detail/impl/win_static_mutex.ipp>
 #endif // defined(BOOST_ASIO_HEADER_ONLY)
 
-#endif // defined(BOOST_WINDOWS)
+#endif // defined(BOOST_ASIO_WINDOWS)
 
 #endif // BOOST_ASIO_DETAIL_WIN_STATIC_MUTEX_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/win_thread.hpp b/3rdParty/Boost/src/boost/asio/detail/win_thread.hpp
index 754786e..889eca6 100644
--- a/3rdParty/Boost/src/boost/asio/detail/win_thread.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/win_thread.hpp
@@ -1,11 +1,11 @@
 //
 // detail/win_thread.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_WIN_THREAD_HPP
@@ -14,13 +14,13 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
-#if defined(BOOST_WINDOWS) && !defined(UNDER_CE)
+#if defined(BOOST_ASIO_WINDOWS) && !defined(UNDER_CE)
 
 #include <boost/asio/detail/noncopyable.hpp>
 #include <boost/asio/detail/socket_types.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
@@ -133,9 +133,9 @@ private:
 #include <boost/asio/detail/pop_options.hpp>
 
 #if defined(BOOST_ASIO_HEADER_ONLY)
 # include <boost/asio/detail/impl/win_thread.ipp>
 #endif // defined(BOOST_ASIO_HEADER_ONLY)
 
-#endif // defined(BOOST_WINDOWS) && !defined(UNDER_CE)
+#endif // defined(BOOST_ASIO_WINDOWS) && !defined(UNDER_CE)
 
 #endif // BOOST_ASIO_DETAIL_WIN_THREAD_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/win_tss_ptr.hpp b/3rdParty/Boost/src/boost/asio/detail/win_tss_ptr.hpp
index 44cacc6..ca32fea 100644
--- a/3rdParty/Boost/src/boost/asio/detail/win_tss_ptr.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/win_tss_ptr.hpp
@@ -1,11 +1,11 @@
 //
 // detail/win_tss_ptr.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_WIN_TSS_PTR_HPP
@@ -14,13 +14,13 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
-#if defined(BOOST_WINDOWS)
+#if defined(BOOST_ASIO_WINDOWS)
 
 #include <boost/asio/detail/noncopyable.hpp>
 #include <boost/asio/detail/socket_types.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
@@ -73,9 +73,9 @@ private:
 #include <boost/asio/detail/pop_options.hpp>
 
 #if defined(BOOST_ASIO_HEADER_ONLY)
 # include <boost/asio/detail/impl/win_tss_ptr.ipp>
 #endif // defined(BOOST_ASIO_HEADER_ONLY)
 
-#endif // defined(BOOST_WINDOWS)
+#endif // defined(BOOST_ASIO_WINDOWS)
 
 #endif // BOOST_ASIO_DETAIL_WIN_TSS_PTR_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/wince_thread.hpp b/3rdParty/Boost/src/boost/asio/detail/wince_thread.hpp
index 389cb9d..6b9104a 100644
--- a/3rdParty/Boost/src/boost/asio/detail/wince_thread.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/wince_thread.hpp
@@ -1,11 +1,11 @@
 //
 // detail/wince_thread.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_WINCE_THREAD_HPP
@@ -14,13 +14,13 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
-#if defined(BOOST_WINDOWS) && defined(UNDER_CE)
+#if defined(BOOST_ASIO_WINDOWS) && defined(UNDER_CE)
 
 #include <memory>
 #include <boost/asio/detail/noncopyable.hpp>
 #include <boost/asio/detail/socket_types.hpp>
 #include <boost/asio/detail/throw_error.hpp>
 #include <boost/asio/error.hpp>
@@ -110,9 +110,9 @@ inline DWORD WINAPI wince_thread_function(LPVOID arg)
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
-#endif // defined(BOOST_WINDOWS) && defined(UNDER_CE)
+#endif // defined(BOOST_ASIO_WINDOWS) && defined(UNDER_CE)
 
 #endif // BOOST_ASIO_DETAIL_WINCE_THREAD_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/winrt_async_manager.hpp b/3rdParty/Boost/src/boost/asio/detail/winrt_async_manager.hpp
new file mode 100644
index 0000000..1c389a0
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/detail/winrt_async_manager.hpp
@@ -0,0 +1,296 @@
+//
+// detail/winrt_async_manager.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_DETAIL_WINRT_ASYNC_MANAGER_HPP
+#define BOOST_ASIO_DETAIL_WINRT_ASYNC_MANAGER_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_WINDOWS_RUNTIME)
+
+#include <future>
+#include <boost/asio/detail/atomic_count.hpp>
+#include <boost/asio/detail/winrt_async_op.hpp>
+#include <boost/asio/error.hpp>
+#include <boost/asio/io_service.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+class winrt_async_manager
+  : public boost::asio::detail::service_base<winrt_async_manager>
+{
+public:
+  // Constructor.
+  winrt_async_manager(boost::asio::io_service& io_service)
+    : boost::asio::detail::service_base<winrt_async_manager>(io_service),
+      io_service_(use_service<io_service_impl>(io_service)),
+      outstanding_ops_(1)
+  {
+  }
+
+  // Destructor.
+  ~winrt_async_manager()
+  {
+  }
+
+  // Destroy all user-defined handler objects owned by the service.
+  void shutdown_service()
+  {
+    if (--outstanding_ops_ > 0)
+    {
+      // Block until last operation is complete.
+      std::future<void> f = promise_.get_future();
+      f.wait();
+    }
+  }
+
+  void sync(Windows::Foundation::IAsyncAction^ action,
+      boost::system::error_code& ec)
+  {
+    using namespace Windows::Foundation;
+    using Windows::Foundation::AsyncStatus;
+
+    auto promise = std::make_shared<std::promise<boost::system::error_code>>();
+    auto future = promise->get_future();
+
+    action->Completed = ref new AsyncActionCompletedHandler(
+      [promise](IAsyncAction^ action, AsyncStatus status)
+      {
+        switch (status)
+        {
+        case AsyncStatus::Canceled:
+          promise->set_value(boost::asio::error::operation_aborted);
+          break;
+        case AsyncStatus::Error:
+        case AsyncStatus::Completed:
+        default:
+          boost::system::error_code ec(
+              action->ErrorCode.Value,
+              boost::system::system_category());
+          promise->set_value(ec);
+          break;
+        }
+      });
+
+    ec = future.get();
+  }
+
+  template <typename TResult>
+  TResult sync(Windows::Foundation::IAsyncOperation<TResult>^ operation,
+      boost::system::error_code& ec)
+  {
+    using namespace Windows::Foundation;
+    using Windows::Foundation::AsyncStatus;
+
+    auto promise = std::make_shared<std::promise<boost::system::error_code>>();
+    auto future = promise->get_future();
+
+    operation->Completed = ref new AsyncOperationCompletedHandler<TResult>(
+      [promise](IAsyncOperation<TResult>^ operation, AsyncStatus status)
+      {
+        switch (status)
+        {
+        case AsyncStatus::Canceled:
+          promise->set_value(boost::asio::error::operation_aborted);
+          break;
+        case AsyncStatus::Error:
+        case AsyncStatus::Completed:
+        default:
+          boost::system::error_code ec(
+              operation->ErrorCode.Value,
+              boost::system::system_category());
+          promise->set_value(ec);
+          break;
+        }
+      });
+
+    ec = future.get();
+    return operation->GetResults();
+  }
+
+  template <typename TResult, typename TProgress>
+  TResult sync(
+      Windows::Foundation::IAsyncOperationWithProgress<
+        TResult, TProgress>^ operation,
+      boost::system::error_code& ec)
+  {
+    using namespace Windows::Foundation;
+    using Windows::Foundation::AsyncStatus;
+
+    auto promise = std::make_shared<std::promise<boost::system::error_code>>();
+    auto future = promise->get_future();
+
+    operation->Completed
+      = ref new AsyncOperationWithProgressCompletedHandler<TResult, TProgress>(
+        [promise](IAsyncOperationWithProgress<TResult, TProgress>^ operation,
+          AsyncStatus status)
+        {
+          switch (status)
+          {
+          case AsyncStatus::Canceled:
+            promise->set_value(boost::asio::error::operation_aborted);
+            break;
+          case AsyncStatus::Started:
+            break;
+          case AsyncStatus::Error:
+          case AsyncStatus::Completed:
+          default:
+            boost::system::error_code ec(
+                operation->ErrorCode.Value,
+                boost::system::system_category());
+            promise->set_value(ec);
+            break;
+          }
+        });
+
+    ec = future.get();
+    return operation->GetResults();
+  }
+
+  void async(Windows::Foundation::IAsyncAction^ action,
+      winrt_async_op<void>* handler)
+  {
+    using namespace Windows::Foundation;
+    using Windows::Foundation::AsyncStatus;
+
+    auto on_completed = ref new AsyncActionCompletedHandler(
+      [this, handler](IAsyncAction^ action, AsyncStatus status)
+      {
+        switch (status)
+        {
+        case AsyncStatus::Canceled:
+          handler->ec_ = boost::asio::error::operation_aborted;
+          break;
+        case AsyncStatus::Started:
+          return;
+        case AsyncStatus::Completed:
+        case AsyncStatus::Error:
+        default:
+          handler->ec_ = boost::system::error_code(
+              action->ErrorCode.Value,
+              boost::system::system_category());
+          break;
+        }
+        io_service_.post_deferred_completion(handler);
+        if (--outstanding_ops_ == 0)
+          promise_.set_value();
+      });
+
+    io_service_.work_started();
+    ++outstanding_ops_;
+    action->Completed = on_completed;
+  }
+
+  template <typename TResult>
+  void async(Windows::Foundation::IAsyncOperation<TResult>^ operation,
+      winrt_async_op<TResult>* handler)
+  {
+    using namespace Windows::Foundation;
+    using Windows::Foundation::AsyncStatus;
+
+    auto on_completed = ref new AsyncOperationCompletedHandler<TResult>(
+      [this, handler](IAsyncOperation<TResult>^ operation, AsyncStatus status)
+      {
+        switch (status)
+        {
+        case AsyncStatus::Canceled:
+          handler->ec_ = boost::asio::error::operation_aborted;
+          break;
+        case AsyncStatus::Started:
+          return;
+        case AsyncStatus::Completed:
+          handler->result_ = operation->GetResults();
+          // Fall through.
+        case AsyncStatus::Error:
+        default:
+          handler->ec_ = boost::system::error_code(
+              operation->ErrorCode.Value,
+              boost::system::system_category());
+          break;
+        }
+        io_service_.post_deferred_completion(handler);
+        if (--outstanding_ops_ == 0)
+          promise_.set_value();
+      });
+
+    io_service_.work_started();
+    ++outstanding_ops_;
+    operation->Completed = on_completed;
+  }
+
+  template <typename TResult, typename TProgress>
+  void async(
+      Windows::Foundation::IAsyncOperationWithProgress<
+        TResult, TProgress>^ operation,
+      winrt_async_op<TResult>* handler)
+  {
+    using namespace Windows::Foundation;
+    using Windows::Foundation::AsyncStatus;
+
+    auto on_completed
+      = ref new AsyncOperationWithProgressCompletedHandler<TResult, TProgress>(
+        [this, handler](IAsyncOperationWithProgress<
+          TResult, TProgress>^ operation, AsyncStatus status)
+        {
+          switch (status)
+          {
+          case AsyncStatus::Canceled:
+            handler->ec_ = boost::asio::error::operation_aborted;
+            break;
+          case AsyncStatus::Started:
+            return;
+          case AsyncStatus::Completed:
+            handler->result_ = operation->GetResults();
+            // Fall through.
+          case AsyncStatus::Error:
+          default:
+            handler->ec_ = boost::system::error_code(
+                operation->ErrorCode.Value,
+                boost::system::system_category());
+            break;
+          }
+          io_service_.post_deferred_completion(handler);
+          if (--outstanding_ops_ == 0)
+            promise_.set_value();
+        });
+
+    io_service_.work_started();
+    ++outstanding_ops_;
+    operation->Completed = on_completed;
+  }
+
+private:
+  // The io_service implementation used to post completed handlers.
+  io_service_impl& io_service_;
+
+  // Count of outstanding operations.
+  atomic_count outstanding_ops_;
+
+  // Used to keep wait for outstanding operations to complete.
+  std::promise<void> promise_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // defined(BOOST_ASIO_WINDOWS_RUNTIME)
+
+#endif // BOOST_ASIO_DETAIL_WINRT_ASYNC_MANAGER_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/winrt_async_op.hpp b/3rdParty/Boost/src/boost/asio/detail/winrt_async_op.hpp
new file mode 100644
index 0000000..cded131
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/detail/winrt_async_op.hpp
@@ -0,0 +1,67 @@
+//
+// detail/winrt_async_op.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_DETAIL_WINRT_ASYNC_OP_HPP
+#define BOOST_ASIO_DETAIL_WINRT_ASYNC_OP_HPP
+
+#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/operation.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+template <typename TResult>
+class winrt_async_op
+  : public operation
+{
+public:
+  // The error code to be passed to the completion handler.
+  boost::system::error_code ec_;
+
+  // The result of the operation, to be passed to the completion handler.
+  TResult result_;
+
+protected:
+  winrt_async_op(func_type complete_func)
+    : operation(complete_func),
+      result_()
+  {
+  }
+};
+
+template <>
+class winrt_async_op<void>
+  : public operation
+{
+public:
+  // The error code to be passed to the completion handler.
+  boost::system::error_code ec_;
+
+protected:
+  winrt_async_op(func_type complete_func)
+    : operation(complete_func)
+  {
+  }
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_DETAIL_WINRT_ASYNC_OP_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/winrt_resolve_op.hpp b/3rdParty/Boost/src/boost/asio/detail/winrt_resolve_op.hpp
new file mode 100644
index 0000000..fa12889
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/detail/winrt_resolve_op.hpp
@@ -0,0 +1,119 @@
+//
+// detail/winrt_resolve_op.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_DETAIL_WINRT_RESOLVE_OP_HPP
+#define BOOST_ASIO_DETAIL_WINRT_RESOLVE_OP_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_WINDOWS_RUNTIME)
+
+#include <boost/asio/detail/addressof.hpp>
+#include <boost/asio/detail/bind_handler.hpp>
+#include <boost/asio/detail/fenced_block.hpp>
+#include <boost/asio/detail/handler_alloc_helpers.hpp>
+#include <boost/asio/detail/handler_invoke_helpers.hpp>
+#include <boost/asio/detail/winrt_async_op.hpp>
+#include <boost/asio/ip/basic_resolver_iterator.hpp>
+#include <boost/asio/error.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+template <typename Protocol, typename Handler>
+class winrt_resolve_op :
+  public winrt_async_op<
+    Windows::Foundation::Collections::IVectorView<
+      Windows::Networking::EndpointPair^>^>
+{
+public:
+  BOOST_ASIO_DEFINE_HANDLER_PTR(winrt_resolve_op);
+
+  typedef typename Protocol::endpoint endpoint_type;
+  typedef boost::asio::ip::basic_resolver_query<Protocol> query_type;
+  typedef boost::asio::ip::basic_resolver_iterator<Protocol> iterator_type;
+
+  winrt_resolve_op(const query_type& query, Handler& handler)
+    : winrt_async_op<
+        Windows::Foundation::Collections::IVectorView<
+          Windows::Networking::EndpointPair^>^>(
+            &winrt_resolve_op::do_complete),
+      query_(query),
+      handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler))
+  {
+  }
+
+  static void do_complete(io_service_impl* owner, operation* base,
+      const boost::system::error_code&, std::size_t)
+  {
+    // Take ownership of the operation object.
+    winrt_resolve_op* o(static_cast<winrt_resolve_op*>(base));
+    ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
+
+    BOOST_ASIO_HANDLER_COMPLETION((o));
+
+    iterator_type iterator = iterator_type();
+    if (!o->ec_)
+    {
+      try
+      {
+        iterator = iterator_type::create(
+            o->result_, o->query_.hints(),
+            o->query_.host_name(), o->query_.service_name());
+      }
+      catch (Platform::Exception^ e)
+      {
+        o->ec_ = boost::system::error_code(e->HResult,
+            boost::system::system_category());
+      }
+    }
+
+    // Make a copy of the handler so that the memory can be deallocated before
+    // the upcall is made. Even if we're not about to make an upcall, a
+    // sub-object of the handler may be the true owner of the memory associated
+    // with the handler. Consequently, a local copy of the handler is required
+    // to ensure that any owning sub-object remains valid until after we have
+    // deallocated the memory here.
+    detail::binder2<Handler, boost::system::error_code, iterator_type>
+      handler(o->handler_, o->ec_, iterator);
+    p.h = boost::asio::detail::addressof(handler.handler_);
+    p.reset();
+
+    // Make the upcall if required.
+    if (owner)
+    {
+      fenced_block b(fenced_block::half);
+      BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
+      boost_asio_handler_invoke_helpers::invoke(handler, handler.handler_);
+      BOOST_ASIO_HANDLER_INVOCATION_END;
+    }
+  }
+
+private:
+  query_type query_;
+  Handler handler_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // defined(BOOST_ASIO_WINDOWS_RUNTIME)
+
+#endif // BOOST_ASIO_DETAIL_WINRT_RESOLVE_OP_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/winrt_resolver_service.hpp b/3rdParty/Boost/src/boost/asio/detail/winrt_resolver_service.hpp
new file mode 100644
index 0000000..624305f
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/detail/winrt_resolver_service.hpp
@@ -0,0 +1,185 @@
+//
+// detail/winrt_resolver_service.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_DETAIL_WINRT_RESOLVER_SERVICE_HPP
+#define BOOST_ASIO_DETAIL_WINRT_RESOLVER_SERVICE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_WINDOWS_RUNTIME)
+
+#include <boost/asio/ip/basic_resolver_iterator.hpp>
+#include <boost/asio/ip/basic_resolver_query.hpp>
+#include <boost/asio/detail/addressof.hpp>
+#include <boost/asio/detail/bind_handler.hpp>
+#include <boost/asio/detail/socket_ops.hpp>
+#include <boost/asio/detail/winrt_async_manager.hpp>
+#include <boost/asio/detail/winrt_resolve_op.hpp>
+#include <boost/asio/detail/winrt_utils.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+template <typename Protocol>
+class winrt_resolver_service
+{
+public:
+  // The implementation type of the resolver. A cancellation token is used to
+  // indicate to the asynchronous operation that the operation has been
+  // cancelled.
+  typedef socket_ops::shared_cancel_token_type implementation_type;
+
+  // The endpoint type.
+  typedef typename Protocol::endpoint endpoint_type;
+
+  // The query type.
+  typedef boost::asio::ip::basic_resolver_query<Protocol> query_type;
+
+  // The iterator type.
+  typedef boost::asio::ip::basic_resolver_iterator<Protocol> iterator_type;
+
+  // Constructor.
+  winrt_resolver_service(boost::asio::io_service& io_service)
+    : io_service_(use_service<io_service_impl>(io_service)),
+      async_manager_(use_service<winrt_async_manager>(io_service))
+  {
+  }
+
+  // Destructor.
+  ~winrt_resolver_service()
+  {
+  }
+
+  // Destroy all user-defined handler objects owned by the service.
+  void shutdown_service()
+  {
+  }
+
+  // Perform any fork-related housekeeping.
+  void fork_service(boost::asio::io_service::fork_event)
+  {
+  }
+
+  // Construct a new resolver implementation.
+  void construct(implementation_type&)
+  {
+  }
+
+  // Destroy a resolver implementation.
+  void destroy(implementation_type&)
+  {
+  }
+
+  // Cancel pending asynchronous operations.
+  void cancel(implementation_type&)
+  {
+  }
+
+  // Resolve a query to a list of entries.
+  iterator_type resolve(implementation_type&,
+      const query_type& query, boost::system::error_code& ec)
+  {
+    try
+    {
+      using namespace Windows::Networking::Sockets;
+      auto endpoint_pairs = async_manager_.sync(
+          DatagramSocket::GetEndpointPairsAsync(
+            winrt_utils::host_name(query.host_name()),
+            winrt_utils::string(query.service_name())), ec);
+
+      if (ec)
+        return iterator_type();
+
+      return iterator_type::create(
+          endpoint_pairs, query.hints(),
+          query.host_name(), query.service_name());
+    }
+    catch (Platform::Exception^ e)
+    {
+      ec = boost::system::error_code(e->HResult,
+          boost::system::system_category());
+      return iterator_type();
+    }
+  }
+
+  // Asynchronously resolve a query to a list of entries.
+  template <typename Handler>
+  void async_resolve(implementation_type&,
+      const query_type& query, Handler& handler)
+  {
+    bool is_continuation =
+      boost_asio_handler_cont_helpers::is_continuation(handler);
+
+    // Allocate and construct an operation to wrap the handler.
+    typedef winrt_resolve_op<Protocol, Handler> op;
+    typename op::ptr p = { boost::asio::detail::addressof(handler),
+      boost_asio_handler_alloc_helpers::allocate(
+        sizeof(op), handler), 0 };
+    p.p = new (p.v) op(query, handler);
+
+    BOOST_ASIO_HANDLER_CREATION((p.p, "resolver", &impl, "async_resolve"));
+
+    try
+    {
+      using namespace Windows::Networking::Sockets;
+      async_manager_.async(DatagramSocket::GetEndpointPairsAsync(
+            winrt_utils::host_name(query.host_name()),
+            winrt_utils::string(query.service_name())), p.p);
+      p.v = p.p = 0;
+    }
+    catch (Platform::Exception^ e)
+    {
+      p.p->ec_ = boost::system::error_code(
+          e->HResult, boost::system::system_category());
+      io_service_.post_immediate_completion(p.p, is_continuation);
+      p.v = p.p = 0;
+    }
+  }
+
+  // Resolve an endpoint to a list of entries.
+  iterator_type resolve(implementation_type&,
+      const endpoint_type&, boost::system::error_code& ec)
+  {
+    ec = boost::asio::error::operation_not_supported;
+    return iterator_type();
+  }
+
+  // Asynchronously resolve an endpoint to a list of entries.
+  template <typename Handler>
+  void async_resolve(implementation_type&,
+      const endpoint_type&, Handler& handler)
+  {
+    boost::system::error_code ec = boost::asio::error::operation_not_supported;
+    const iterator_type iterator;
+    io_service_.get_io_service().post(
+        detail::bind_handler(handler, ec, iterator));
+  }
+
+private:
+  io_service_impl& io_service_;
+  winrt_async_manager& async_manager_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // defined(BOOST_ASIO_WINDOWS_RUNTIME)
+
+#endif // BOOST_ASIO_DETAIL_WINRT_RESOLVER_SERVICE_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/winrt_socket_connect_op.hpp b/3rdParty/Boost/src/boost/asio/detail/winrt_socket_connect_op.hpp
new file mode 100644
index 0000000..0e3f230
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/detail/winrt_socket_connect_op.hpp
@@ -0,0 +1,92 @@
+//
+// detail/winrt_socket_connect_op.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_DETAIL_WINRT_SOCKET_CONNECT_OP_HPP
+#define BOOST_ASIO_DETAIL_WINRT_SOCKET_CONNECT_OP_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_WINDOWS_RUNTIME)
+
+#include <boost/asio/detail/addressof.hpp>
+#include <boost/asio/detail/bind_handler.hpp>
+#include <boost/asio/detail/buffer_sequence_adapter.hpp>
+#include <boost/asio/detail/fenced_block.hpp>
+#include <boost/asio/detail/handler_alloc_helpers.hpp>
+#include <boost/asio/detail/handler_invoke_helpers.hpp>
+#include <boost/asio/detail/winrt_async_op.hpp>
+#include <boost/asio/error.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+template <typename Handler>
+class winrt_socket_connect_op :
+  public winrt_async_op<void>
+{
+public:
+  BOOST_ASIO_DEFINE_HANDLER_PTR(winrt_socket_connect_op);
+
+  winrt_socket_connect_op(Handler& handler)
+    : winrt_async_op<void>(&winrt_socket_connect_op::do_complete),
+      handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler))
+  {
+  }
+
+  static void do_complete(io_service_impl* owner, operation* base,
+      const boost::system::error_code&, std::size_t)
+  {
+    // Take ownership of the operation object.
+    winrt_socket_connect_op* o(static_cast<winrt_socket_connect_op*>(base));
+    ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
+
+    BOOST_ASIO_HANDLER_COMPLETION((o));
+
+    // Make a copy of the handler so that the memory can be deallocated before
+    // the upcall is made. Even if we're not about to make an upcall, a
+    // sub-object of the handler may be the true owner of the memory associated
+    // with the handler. Consequently, a local copy of the handler is required
+    // to ensure that any owning sub-object remains valid until after we have
+    // deallocated the memory here.
+    detail::binder1<Handler, boost::system::error_code>
+      handler(o->handler_, o->ec_);
+    p.h = boost::asio::detail::addressof(handler.handler_);
+    p.reset();
+
+    // Make the upcall if required.
+    if (owner)
+    {
+      fenced_block b(fenced_block::half);
+      BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
+      boost_asio_handler_invoke_helpers::invoke(handler, handler.handler_);
+      BOOST_ASIO_HANDLER_INVOCATION_END;
+    }
+  }
+
+private:
+  Handler handler_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // defined(BOOST_ASIO_WINDOWS_RUNTIME)
+
+#endif // BOOST_ASIO_DETAIL_WINRT_SOCKET_CONNECT_OP_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/winrt_socket_recv_op.hpp b/3rdParty/Boost/src/boost/asio/detail/winrt_socket_recv_op.hpp
new file mode 100644
index 0000000..5654568
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/detail/winrt_socket_recv_op.hpp
@@ -0,0 +1,112 @@
+//
+// detail/winrt_socket_recv_op.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_DETAIL_WINRT_SOCKET_RECV_OP_HPP
+#define BOOST_ASIO_DETAIL_WINRT_SOCKET_RECV_OP_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_WINDOWS_RUNTIME)
+
+#include <boost/asio/detail/addressof.hpp>
+#include <boost/asio/detail/bind_handler.hpp>
+#include <boost/asio/detail/buffer_sequence_adapter.hpp>
+#include <boost/asio/detail/fenced_block.hpp>
+#include <boost/asio/detail/handler_alloc_helpers.hpp>
+#include <boost/asio/detail/handler_invoke_helpers.hpp>
+#include <boost/asio/detail/winrt_async_op.hpp>
+#include <boost/asio/error.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+template <typename MutableBufferSequence, typename Handler>
+class winrt_socket_recv_op :
+  public winrt_async_op<Windows::Storage::Streams::IBuffer^>
+{
+public:
+  BOOST_ASIO_DEFINE_HANDLER_PTR(winrt_socket_recv_op);
+
+  winrt_socket_recv_op(const MutableBufferSequence& buffers, Handler& handler)
+    : winrt_async_op<Windows::Storage::Streams::IBuffer^>(
+          &winrt_socket_recv_op::do_complete),
+      buffers_(buffers),
+      handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler))
+  {
+  }
+
+  static void do_complete(io_service_impl* owner, operation* base,
+      const boost::system::error_code&, std::size_t)
+  {
+    // Take ownership of the operation object.
+    winrt_socket_recv_op* o(static_cast<winrt_socket_recv_op*>(base));
+    ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
+
+    BOOST_ASIO_HANDLER_COMPLETION((o));
+
+#if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)
+    // Check whether buffers are still valid.
+    if (owner)
+    {
+      buffer_sequence_adapter<boost::asio::mutable_buffer,
+          MutableBufferSequence>::validate(o->buffers_);
+    }
+#endif // defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)
+
+    std::size_t bytes_transferred = o->result_ ? o->result_->Length : 0;
+    if (bytes_transferred == 0 && !o->ec_ &&
+        !buffer_sequence_adapter<boost::asio::mutable_buffer,
+          MutableBufferSequence>::all_empty(o->buffers_))
+    {
+      o->ec_ = boost::asio::error::eof;
+    }
+
+    // Make a copy of the handler so that the memory can be deallocated before
+    // the upcall is made. Even if we're not about to make an upcall, a
+    // sub-object of the handler may be the true owner of the memory associated
+    // with the handler. Consequently, a local copy of the handler is required
+    // to ensure that any owning sub-object remains valid until after we have
+    // deallocated the memory here.
+    detail::binder2<Handler, boost::system::error_code, std::size_t>
+      handler(o->handler_, o->ec_, bytes_transferred);
+    p.h = boost::asio::detail::addressof(handler.handler_);
+    p.reset();
+
+    // Make the upcall if required.
+    if (owner)
+    {
+      fenced_block b(fenced_block::half);
+      BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
+      boost_asio_handler_invoke_helpers::invoke(handler, handler.handler_);
+      BOOST_ASIO_HANDLER_INVOCATION_END;
+    }
+  }
+
+private:
+  MutableBufferSequence buffers_;
+  Handler handler_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // defined(BOOST_ASIO_WINDOWS_RUNTIME)
+
+#endif // BOOST_ASIO_DETAIL_WINRT_SOCKET_RECV_OP_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/winrt_socket_send_op.hpp b/3rdParty/Boost/src/boost/asio/detail/winrt_socket_send_op.hpp
new file mode 100644
index 0000000..ef36766
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/detail/winrt_socket_send_op.hpp
@@ -0,0 +1,103 @@
+//
+// detail/winrt_socket_send_op.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_DETAIL_WINRT_SOCKET_SEND_OP_HPP
+#define BOOST_ASIO_DETAIL_WINRT_SOCKET_SEND_OP_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_WINDOWS_RUNTIME)
+
+#include <boost/asio/detail/addressof.hpp>
+#include <boost/asio/detail/bind_handler.hpp>
+#include <boost/asio/detail/buffer_sequence_adapter.hpp>
+#include <boost/asio/detail/fenced_block.hpp>
+#include <boost/asio/detail/handler_alloc_helpers.hpp>
+#include <boost/asio/detail/handler_invoke_helpers.hpp>
+#include <boost/asio/detail/winrt_async_op.hpp>
+#include <boost/asio/error.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+template <typename ConstBufferSequence, typename Handler>
+class winrt_socket_send_op :
+  public winrt_async_op<unsigned int>
+{
+public:
+  BOOST_ASIO_DEFINE_HANDLER_PTR(winrt_socket_send_op);
+
+  winrt_socket_send_op(const ConstBufferSequence& buffers, Handler& handler)
+    : winrt_async_op<unsigned int>(&winrt_socket_send_op::do_complete),
+      buffers_(buffers),
+      handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler))
+  {
+  }
+
+  static void do_complete(io_service_impl* owner, operation* base,
+      const boost::system::error_code&, std::size_t)
+  {
+    // Take ownership of the operation object.
+    winrt_socket_send_op* o(static_cast<winrt_socket_send_op*>(base));
+    ptr p = { boost::asio::detail::addressof(o->handler_), o, o };
+
+    BOOST_ASIO_HANDLER_COMPLETION((o));
+
+#if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)
+    // Check whether buffers are still valid.
+    if (owner)
+    {
+      buffer_sequence_adapter<boost::asio::const_buffer,
+          ConstBufferSequence>::validate(o->buffers_);
+    }
+#endif // defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)
+
+    // Make a copy of the handler so that the memory can be deallocated before
+    // the upcall is made. Even if we're not about to make an upcall, a
+    // sub-object of the handler may be the true owner of the memory associated
+    // with the handler. Consequently, a local copy of the handler is required
+    // to ensure that any owning sub-object remains valid until after we have
+    // deallocated the memory here.
+    detail::binder2<Handler, boost::system::error_code, std::size_t>
+      handler(o->handler_, o->ec_, o->result_);
+    p.h = boost::asio::detail::addressof(handler.handler_);
+    p.reset();
+
+    // Make the upcall if required.
+    if (owner)
+    {
+      fenced_block b(fenced_block::half);
+      BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
+      boost_asio_handler_invoke_helpers::invoke(handler, handler.handler_);
+      BOOST_ASIO_HANDLER_INVOCATION_END;
+    }
+  }
+
+private:
+  ConstBufferSequence buffers_;
+  Handler handler_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // defined(BOOST_ASIO_WINDOWS_RUNTIME)
+
+#endif // BOOST_ASIO_DETAIL_WINRT_SOCKET_SEND_OP_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/winrt_ssocket_service.hpp b/3rdParty/Boost/src/boost/asio/detail/winrt_ssocket_service.hpp
new file mode 100644
index 0000000..a701efa
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/detail/winrt_ssocket_service.hpp
@@ -0,0 +1,234 @@
+//
+// detail/winrt_ssocket_service.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_DETAIL_WINRT_SSOCKET_SERVICE_HPP
+#define BOOST_ASIO_DETAIL_WINRT_SSOCKET_SERVICE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_WINDOWS_RUNTIME)
+
+#include <boost/asio/error.hpp>
+#include <boost/asio/io_service.hpp>
+#include <boost/asio/detail/addressof.hpp>
+#include <boost/asio/detail/winrt_socket_connect_op.hpp>
+#include <boost/asio/detail/winrt_ssocket_service_base.hpp>
+#include <boost/asio/detail/winrt_utils.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+template <typename Protocol>
+class winrt_ssocket_service :
+  public winrt_ssocket_service_base
+{
+public:
+  // The protocol type.
+  typedef Protocol protocol_type;
+
+  // The endpoint type.
+  typedef typename Protocol::endpoint endpoint_type;
+
+  // The native type of a socket.
+  typedef Windows::Networking::Sockets::StreamSocket^ native_handle_type;
+
+  // The implementation type of the socket.
+  struct implementation_type : base_implementation_type
+  {
+    // Default constructor.
+    implementation_type()
+      : base_implementation_type(),
+        protocol_(endpoint_type().protocol())
+    {
+    }
+
+    // The protocol associated with the socket.
+    protocol_type protocol_;
+  };
+
+  // Constructor.
+  winrt_ssocket_service(boost::asio::io_service& io_service)
+    : winrt_ssocket_service_base(io_service)
+  {
+  }
+
+  // Move-construct a new socket implementation.
+  void move_construct(implementation_type& impl,
+      implementation_type& other_impl)
+  {
+    this->base_move_construct(impl, other_impl);
+
+    impl.protocol_ = other_impl.protocol_;
+    other_impl.protocol_ = endpoint_type().protocol();
+  }
+
+  // Move-assign from another socket implementation.
+  void move_assign(implementation_type& impl,
+      winrt_ssocket_service& other_service,
+      implementation_type& other_impl)
+  {
+    this->base_move_assign(impl, other_service, other_impl);
+
+    impl.protocol_ = other_impl.protocol_;
+    other_impl.protocol_ = endpoint_type().protocol();
+  }
+
+  // Move-construct a new socket implementation from another protocol type.
+  template <typename Protocol1>
+  void converting_move_construct(implementation_type& impl,
+      typename winrt_ssocket_service<
+        Protocol1>::implementation_type& other_impl)
+  {
+    this->base_move_construct(impl, other_impl);
+
+    impl.protocol_ = protocol_type(other_impl.protocol_);
+    other_impl.protocol_ = typename Protocol1::endpoint().protocol();
+  }
+
+  // Open a new socket implementation.
+  boost::system::error_code open(implementation_type& impl,
+      const protocol_type& protocol, boost::system::error_code& ec)
+  {
+    if (is_open(impl))
+    {
+      ec = boost::asio::error::already_open;
+      return ec;
+    }
+
+    try
+    {
+      impl.socket_ = ref new Windows::Networking::Sockets::StreamSocket;
+      impl.protocol_ = protocol;
+      ec = boost::system::error_code();
+    }
+    catch (Platform::Exception^ e)
+    {
+      ec = boost::system::error_code(e->HResult,
+            boost::system::system_category());
+    }
+
+    return ec;
+  }
+
+  // Assign a native socket to a socket implementation.
+  boost::system::error_code assign(implementation_type& impl,
+      const protocol_type& protocol, const native_handle_type& native_socket,
+      boost::system::error_code& ec)
+  {
+    if (is_open(impl))
+    {
+      ec = boost::asio::error::already_open;
+      return ec;
+    }
+
+    impl.socket_ = native_socket;
+    impl.protocol_ = protocol;
+    ec = boost::system::error_code();
+
+    return ec;
+  }
+
+  // Bind the socket to the specified local endpoint.
+  boost::system::error_code bind(implementation_type&,
+      const endpoint_type&, boost::system::error_code& ec)
+  {
+    ec = boost::asio::error::operation_not_supported;
+    return ec;
+  }
+
+  // Get the local endpoint.
+  endpoint_type local_endpoint(const implementation_type& impl,
+      boost::system::error_code& ec) const
+  {
+    endpoint_type endpoint;
+    endpoint.resize(do_get_endpoint(impl, true,
+          endpoint.data(), endpoint.size(), ec));
+    return endpoint;
+  }
+
+  // Get the remote endpoint.
+  endpoint_type remote_endpoint(const implementation_type& impl,
+      boost::system::error_code& ec) const
+  {
+    endpoint_type endpoint;
+    endpoint.resize(do_get_endpoint(impl, false,
+          endpoint.data(), endpoint.size(), ec));
+    return endpoint;
+  }
+
+  // Set a socket option.
+  template <typename Option>
+  boost::system::error_code set_option(implementation_type& impl,
+      const Option& option, boost::system::error_code& ec)
+  {
+    return do_set_option(impl, option.level(impl.protocol_),
+        option.name(impl.protocol_), option.data(impl.protocol_),
+        option.size(impl.protocol_), ec);
+  }
+
+  // Get a socket option.
+  template <typename Option>
+  boost::system::error_code get_option(const implementation_type& impl,
+      Option& option, boost::system::error_code& ec) const
+  {
+    std::size_t size = option.size(impl.protocol_);
+    do_get_option(impl, option.level(impl.protocol_),
+        option.name(impl.protocol_),
+        option.data(impl.protocol_), &size, ec);
+    if (!ec)
+      option.resize(impl.protocol_, size);
+    return ec;
+  }
+
+  // Connect the socket to the specified endpoint.
+  boost::system::error_code connect(implementation_type& impl,
+      const endpoint_type& peer_endpoint, boost::system::error_code& ec)
+  {
+    return do_connect(impl, peer_endpoint.data(), ec);
+  }
+
+  // Start an asynchronous connect.
+  template <typename Handler>
+  void async_connect(implementation_type& impl,
+      const endpoint_type& peer_endpoint, Handler& handler)
+  {
+    bool is_continuation =
+      boost_asio_handler_cont_helpers::is_continuation(handler);
+
+    // Allocate and construct an operation to wrap the handler.
+    typedef winrt_socket_connect_op<Handler> op;
+    typename op::ptr p = { boost::asio::detail::addressof(handler),
+      boost_asio_handler_alloc_helpers::allocate(
+        sizeof(op), handler), 0 };
+    p.p = new (p.v) op(handler);
+
+    BOOST_ASIO_HANDLER_CREATION((p.p, "socket", &impl, "async_connect"));
+
+    start_connect_op(impl, peer_endpoint.data(), p.p, is_continuation);
+    p.v = p.p = 0;
+  }
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // defined(BOOST_ASIO_WINDOWS_RUNTIME)
+
+#endif // BOOST_ASIO_DETAIL_WINRT_SSOCKET_SERVICE_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/winrt_ssocket_service_base.hpp b/3rdParty/Boost/src/boost/asio/detail/winrt_ssocket_service_base.hpp
new file mode 100644
index 0000000..02469ef
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/detail/winrt_ssocket_service_base.hpp
@@ -0,0 +1,357 @@
+//
+// detail/winrt_ssocket_service_base.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_DETAIL_WINRT_SSOCKET_SERVICE_BASE_HPP
+#define BOOST_ASIO_DETAIL_WINRT_SSOCKET_SERVICE_BASE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_WINDOWS_RUNTIME)
+
+#include <boost/asio/buffer.hpp>
+#include <boost/asio/error.hpp>
+#include <boost/asio/io_service.hpp>
+#include <boost/asio/socket_base.hpp>
+#include <boost/asio/detail/addressof.hpp>
+#include <boost/asio/detail/buffer_sequence_adapter.hpp>
+#include <boost/asio/detail/socket_types.hpp>
+#include <boost/asio/detail/winrt_async_manager.hpp>
+#include <boost/asio/detail/winrt_socket_recv_op.hpp>
+#include <boost/asio/detail/winrt_socket_send_op.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+class winrt_ssocket_service_base
+{
+public:
+  // The native type of a socket.
+  typedef Windows::Networking::Sockets::StreamSocket^ native_handle_type;
+
+  // The implementation type of the socket.
+  struct base_implementation_type
+  {
+    // Default constructor.
+    base_implementation_type()
+      : socket_(nullptr),
+        next_(0),
+        prev_(0)
+    {
+    }
+
+    // The underlying native socket.
+    native_handle_type socket_;
+
+    // Pointers to adjacent socket implementations in linked list.
+    base_implementation_type* next_;
+    base_implementation_type* prev_;
+  };
+
+  // Constructor.
+  BOOST_ASIO_DECL winrt_ssocket_service_base(
+      boost::asio::io_service& io_service);
+
+  // Destroy all user-defined handler objects owned by the service.
+  BOOST_ASIO_DECL void shutdown_service();
+
+  // Construct a new socket implementation.
+  BOOST_ASIO_DECL void construct(base_implementation_type&);
+
+  // Move-construct a new socket implementation.
+  BOOST_ASIO_DECL void base_move_construct(base_implementation_type& impl,
+      base_implementation_type& other_impl);
+
+  // Move-assign from another socket implementation.
+  BOOST_ASIO_DECL void base_move_assign(base_implementation_type& impl,
+      winrt_ssocket_service_base& other_service,
+      base_implementation_type& other_impl);
+
+  // Destroy a socket implementation.
+  BOOST_ASIO_DECL void destroy(base_implementation_type& impl);
+
+  // Determine whether the socket is open.
+  bool is_open(const base_implementation_type& impl) const
+  {
+    return impl.socket_ != nullptr;
+  }
+
+  // Destroy a socket implementation.
+  BOOST_ASIO_DECL boost::system::error_code close(
+      base_implementation_type& impl, boost::system::error_code& ec);
+
+  // Get the native socket representation.
+  native_handle_type native_handle(base_implementation_type& impl)
+  {
+    return impl.socket_;
+  }
+
+  // Cancel all operations associated with the socket.
+  boost::system::error_code cancel(base_implementation_type&,
+      boost::system::error_code& ec)
+  {
+    ec = boost::asio::error::operation_not_supported;
+    return ec;
+  }
+
+  // Determine whether the socket is at the out-of-band data mark.
+  bool at_mark(const base_implementation_type&,
+      boost::system::error_code& ec) const
+  {
+    ec = boost::asio::error::operation_not_supported;
+    return false;
+  }
+
+  // Determine the number of bytes available for reading.
+  std::size_t available(const base_implementation_type&,
+      boost::system::error_code& ec) const
+  {
+    ec = boost::asio::error::operation_not_supported;
+    return 0;
+  }
+
+  // Perform an IO control command on the socket.
+  template <typename IO_Control_Command>
+  boost::system::error_code io_control(base_implementation_type&,
+      IO_Control_Command&, boost::system::error_code& ec)
+  {
+    ec = boost::asio::error::operation_not_supported;
+    return ec;
+  }
+
+  // Gets the non-blocking mode of the socket.
+  bool non_blocking(const base_implementation_type&) const
+  {
+    return false;
+  }
+
+  // Sets the non-blocking mode of the socket.
+  boost::system::error_code non_blocking(base_implementation_type&,
+      bool, boost::system::error_code& ec)
+  {
+    ec = boost::asio::error::operation_not_supported;
+    return ec;
+  }
+
+  // Gets the non-blocking mode of the native socket implementation.
+  bool native_non_blocking(const base_implementation_type&) const
+  {
+    return false;
+  }
+
+  // Sets the non-blocking mode of the native socket implementation.
+  boost::system::error_code native_non_blocking(base_implementation_type&,
+      bool, boost::system::error_code& ec)
+  {
+    ec = boost::asio::error::operation_not_supported;
+    return ec;
+  }
+
+  // Disable sends or receives on the socket.
+  boost::system::error_code shutdown(base_implementation_type&,
+      socket_base::shutdown_type, boost::system::error_code& ec)
+  {
+    ec = boost::asio::error::operation_not_supported;
+    return ec;
+  }
+
+  // Send the given data to the peer.
+  template <typename ConstBufferSequence>
+  std::size_t send(base_implementation_type& impl,
+      const ConstBufferSequence& buffers,
+      socket_base::message_flags flags, boost::system::error_code& ec)
+  {
+    return do_send(impl,
+        buffer_sequence_adapter<boost::asio::const_buffer,
+          ConstBufferSequence>::first(buffers), flags, ec);
+  }
+
+  // Wait until data can be sent without blocking.
+  std::size_t send(base_implementation_type&, const null_buffers&,
+      socket_base::message_flags, boost::system::error_code& ec)
+  {
+    ec = boost::asio::error::operation_not_supported;
+    return 0;
+  }
+
+  // Start an asynchronous send. The data being sent must be valid for the
+  // lifetime of the asynchronous operation.
+  template <typename ConstBufferSequence, typename Handler>
+  void async_send(base_implementation_type& impl,
+      const ConstBufferSequence& buffers,
+      socket_base::message_flags flags, Handler& handler)
+  {
+    bool is_continuation =
+      boost_asio_handler_cont_helpers::is_continuation(handler);
+
+    // Allocate and construct an operation to wrap the handler.
+    typedef winrt_socket_send_op<ConstBufferSequence, Handler> op;
+    typename op::ptr p = { boost::asio::detail::addressof(handler),
+      boost_asio_handler_alloc_helpers::allocate(
+        sizeof(op), handler), 0 };
+    p.p = new (p.v) op(buffers, handler);
+
+    BOOST_ASIO_HANDLER_CREATION((p.p, "socket", &impl, "async_send"));
+
+    start_send_op(impl,
+        buffer_sequence_adapter<boost::asio::const_buffer,
+          ConstBufferSequence>::first(buffers),
+        flags, p.p, is_continuation);
+    p.v = p.p = 0;
+  }
+
+  // Start an asynchronous wait until data can be sent without blocking.
+  template <typename Handler>
+  void async_send(base_implementation_type&, const null_buffers&,
+      socket_base::message_flags, Handler& handler)
+  {
+    boost::system::error_code ec = boost::asio::error::operation_not_supported;
+    const std::size_t bytes_transferred = 0;
+    io_service_.get_io_service().post(
+        detail::bind_handler(handler, ec, bytes_transferred));
+  }
+
+  // Receive some data from the peer. Returns the number of bytes received.
+  template <typename MutableBufferSequence>
+  std::size_t receive(base_implementation_type& impl,
+      const MutableBufferSequence& buffers,
+      socket_base::message_flags flags, boost::system::error_code& ec)
+  {
+    return do_receive(impl,
+        buffer_sequence_adapter<boost::asio::mutable_buffer,
+          MutableBufferSequence>::first(buffers), flags, ec);
+  }
+
+  // Wait until data can be received without blocking.
+  std::size_t receive(base_implementation_type&, const null_buffers&,
+      socket_base::message_flags, boost::system::error_code& ec)
+  {
+    ec = boost::asio::error::operation_not_supported;
+    return 0;
+  }
+
+  // Start an asynchronous receive. The buffer for the data being received
+  // must be valid for the lifetime of the asynchronous operation.
+  template <typename MutableBufferSequence, typename Handler>
+  void async_receive(base_implementation_type& impl,
+      const MutableBufferSequence& buffers,
+      socket_base::message_flags flags, Handler& handler)
+  {
+    bool is_continuation =
+      boost_asio_handler_cont_helpers::is_continuation(handler);
+
+    // Allocate and construct an operation to wrap the handler.
+    typedef winrt_socket_recv_op<MutableBufferSequence, Handler> op;
+    typename op::ptr p = { boost::asio::detail::addressof(handler),
+      boost_asio_handler_alloc_helpers::allocate(
+        sizeof(op), handler), 0 };
+    p.p = new (p.v) op(buffers, handler);
+
+    BOOST_ASIO_HANDLER_CREATION((p.p, "socket", &impl, "async_receive"));
+
+    start_receive_op(impl,
+        buffer_sequence_adapter<boost::asio::mutable_buffer,
+          MutableBufferSequence>::first(buffers),
+        flags, p.p, is_continuation);
+    p.v = p.p = 0;
+  }
+
+  // Wait until data can be received without blocking.
+  template <typename Handler>
+  void async_receive(base_implementation_type&, const null_buffers&,
+      socket_base::message_flags, Handler& handler)
+  {
+    boost::system::error_code ec = boost::asio::error::operation_not_supported;
+    const std::size_t bytes_transferred = 0;
+    io_service_.get_io_service().post(
+        detail::bind_handler(handler, ec, bytes_transferred));
+  }
+
+protected:
+  // Helper function to obtain endpoints associated with the connection.
+  BOOST_ASIO_DECL std::size_t do_get_endpoint(
+      const base_implementation_type& impl, bool local,
+      void* addr, std::size_t addr_len, boost::system::error_code& ec) const;
+
+  // Helper function to set a socket option.
+  BOOST_ASIO_DECL boost::system::error_code do_set_option(
+      base_implementation_type& impl,
+      int level, int optname, const void* optval,
+      std::size_t optlen, boost::system::error_code& ec);
+
+  // Helper function to get a socket option.
+  BOOST_ASIO_DECL void do_get_option(
+      const base_implementation_type& impl,
+      int level, int optname, void* optval,
+      std::size_t* optlen, boost::system::error_code& ec) const;
+
+  // Helper function to perform a synchronous connect.
+  BOOST_ASIO_DECL boost::system::error_code do_connect(
+      base_implementation_type& impl,
+      const void* addr, boost::system::error_code& ec);
+
+  // Helper function to start an asynchronous connect.
+  BOOST_ASIO_DECL void start_connect_op(
+      base_implementation_type& impl, const void* addr,
+      winrt_async_op<void>* op, bool is_continuation);
+
+  // Helper function to perform a synchronous send.
+  BOOST_ASIO_DECL std::size_t do_send(
+      base_implementation_type& impl, const boost::asio::const_buffer& data,
+      socket_base::message_flags flags, boost::system::error_code& ec);
+
+  // Helper function to start an asynchronous send.
+  BOOST_ASIO_DECL void start_send_op(base_implementation_type& impl,
+      const boost::asio::const_buffer& data, socket_base::message_flags flags,
+      winrt_async_op<unsigned int>* op, bool is_continuation);
+
+  // Helper function to perform a synchronous receive.
+  BOOST_ASIO_DECL std::size_t do_receive(
+      base_implementation_type& impl, const boost::asio::mutable_buffer& data,
+      socket_base::message_flags flags, boost::system::error_code& ec);
+
+  // Helper function to start an asynchronous receive.
+  BOOST_ASIO_DECL void start_receive_op(base_implementation_type& impl,
+      const boost::asio::mutable_buffer& data, socket_base::message_flags flags,
+      winrt_async_op<Windows::Storage::Streams::IBuffer^>* op,
+      bool is_continuation);
+
+  // The io_service implementation used for delivering completions.
+  io_service_impl& io_service_;
+
+  // The manager that keeps track of outstanding operations.
+  winrt_async_manager& async_manager_;
+
+  // Mutex to protect access to the linked list of implementations. 
+  boost::asio::detail::mutex mutex_;
+
+  // The head of a linked list of all implementations.
+  base_implementation_type* impl_list_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#if defined(BOOST_ASIO_HEADER_ONLY)
+# include <boost/asio/detail/impl/winrt_ssocket_service_base.ipp>
+#endif // defined(BOOST_ASIO_HEADER_ONLY)
+
+#endif // defined(BOOST_ASIO_WINDOWS_RUNTIME)
+
+#endif // BOOST_ASIO_DETAIL_WINRT_SSOCKET_SERVICE_BASE_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/winrt_timer_scheduler.hpp b/3rdParty/Boost/src/boost/asio/detail/winrt_timer_scheduler.hpp
new file mode 100644
index 0000000..9cadeca
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/detail/winrt_timer_scheduler.hpp
@@ -0,0 +1,133 @@
+//
+// detail/winrt_timer_scheduler.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_DETAIL_WINRT_TIMER_SCHEDULER_HPP
+#define BOOST_ASIO_DETAIL_WINRT_TIMER_SCHEDULER_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_WINDOWS_RUNTIME)
+
+#include <cstddef>
+#include <boost/asio/detail/event.hpp>
+#include <boost/asio/detail/limits.hpp>
+#include <boost/asio/detail/mutex.hpp>
+#include <boost/asio/detail/op_queue.hpp>
+#include <boost/asio/detail/thread.hpp>
+#include <boost/asio/detail/timer_queue_base.hpp>
+#include <boost/asio/detail/timer_queue_set.hpp>
+#include <boost/asio/detail/wait_op.hpp>
+#include <boost/asio/io_service.hpp>
+
+#if defined(BOOST_ASIO_HAS_IOCP)
+# include <boost/asio/detail/thread.hpp>
+#endif // defined(BOOST_ASIO_HAS_IOCP)
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+
+class winrt_timer_scheduler
+  : public boost::asio::detail::service_base<winrt_timer_scheduler>
+{
+public:
+  // Constructor.
+  BOOST_ASIO_DECL winrt_timer_scheduler(boost::asio::io_service& io_service);
+
+  // Destructor.
+  BOOST_ASIO_DECL ~winrt_timer_scheduler();
+
+  // Destroy all user-defined handler objects owned by the service.
+  BOOST_ASIO_DECL void shutdown_service();
+
+  // Recreate internal descriptors following a fork.
+  BOOST_ASIO_DECL void fork_service(
+      boost::asio::io_service::fork_event fork_ev);
+
+  // Initialise the task. No effect as this class uses its own thread.
+  BOOST_ASIO_DECL void init_task();
+
+  // Add a new timer queue to the reactor.
+  template <typename Time_Traits>
+  void add_timer_queue(timer_queue<Time_Traits>& queue);
+
+  // Remove a timer queue from the reactor.
+  template <typename Time_Traits>
+  void remove_timer_queue(timer_queue<Time_Traits>& queue);
+
+  // Schedule a new operation in the given timer queue to expire at the
+  // specified absolute time.
+  template <typename Time_Traits>
+  void schedule_timer(timer_queue<Time_Traits>& queue,
+      const typename Time_Traits::time_type& time,
+      typename timer_queue<Time_Traits>::per_timer_data& timer, wait_op* op);
+
+  // Cancel the timer operations associated with the given token. Returns the
+  // number of operations that have been posted or dispatched.
+  template <typename Time_Traits>
+  std::size_t cancel_timer(timer_queue<Time_Traits>& queue,
+      typename timer_queue<Time_Traits>::per_timer_data& timer,
+      std::size_t max_cancelled = (std::numeric_limits<std::size_t>::max)());
+
+private:
+  // Run the select loop in the thread.
+  BOOST_ASIO_DECL void run_thread();
+
+  // Entry point for the select loop thread.
+  BOOST_ASIO_DECL static void call_run_thread(winrt_timer_scheduler* reactor);
+
+  // Helper function to add a new timer queue.
+  BOOST_ASIO_DECL void do_add_timer_queue(timer_queue_base& queue);
+
+  // Helper function to remove a timer queue.
+  BOOST_ASIO_DECL void do_remove_timer_queue(timer_queue_base& queue);
+
+  // The io_service implementation used to post completions.
+  io_service_impl& io_service_;
+
+  // Mutex used to protect internal variables.
+  boost::asio::detail::mutex mutex_;
+
+  // Event used to wake up background thread.
+  boost::asio::detail::event event_;
+
+  // The timer queues.
+  timer_queue_set timer_queues_;
+
+  // The background thread that is waiting for timers to expire.
+  boost::asio::detail::thread* thread_;
+
+  // Does the background thread need to stop.
+  bool stop_thread_;
+
+  // Whether the service has been shut down.
+  bool shutdown_;
+};
+
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#include <boost/asio/detail/impl/winrt_timer_scheduler.hpp>
+#if defined(BOOST_ASIO_HEADER_ONLY)
+# include <boost/asio/detail/impl/winrt_timer_scheduler.ipp>
+#endif // defined(BOOST_ASIO_HEADER_ONLY)
+
+#endif // defined(BOOST_ASIO_WINDOWS_RUNTIME)
+
+#endif // BOOST_ASIO_DETAIL_WINRT_TIMER_SCHEDULER_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/winrt_utils.hpp b/3rdParty/Boost/src/boost/asio/detail/winrt_utils.hpp
new file mode 100644
index 0000000..3b10b07
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/detail/winrt_utils.hpp
@@ -0,0 +1,108 @@
+//
+// detail/winrt_utils.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_DETAIL_WINRT_UTILS_HPP
+#define BOOST_ASIO_DETAIL_WINRT_UTILS_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_WINDOWS_RUNTIME)
+
+#include <codecvt>
+#include <cstdlib>
+#include <future>
+#include <locale>
+#include <memory>
+#include <robuffer.h>
+#include <windows.storage.streams.h>
+#include <wrl/implements.h>
+#include <boost/asio/buffer.hpp>
+#include <boost/system/error_code.hpp>
+#include <boost/asio/detail/addressof.hpp>
+#include <boost/asio/detail/socket_ops.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace detail {
+namespace winrt_utils {
+
+inline Platform::String^ string(const char* from)
+{
+  std::wstring tmp(from, from + std::strlen(from));
+  return ref new Platform::String(tmp.c_str());
+}
+
+inline Platform::String^ string(const std::string& from)
+{
+  std::wstring tmp(from.begin(), from.end());
+  return ref new Platform::String(tmp.c_str());
+}
+
+inline std::string string(Platform::String^ from)
+{
+  std::wstring_convert<std::codecvt_utf8<wchar_t>> converter;
+  return converter.to_bytes(from->Data());
+}
+
+inline Platform::String^ string(unsigned short from)
+{
+  return string(std::to_string(from));
+}
+
+template <typename T>
+inline Platform::String^ string(const T& from)
+{
+  return string(from.to_string());
+}
+
+inline int integer(Platform::String^ from)
+{
+  return _wtoi(from->Data());
+}
+
+template <typename T>
+inline Windows::Networking::HostName^ host_name(const T& from)
+{
+  return ref new Windows::Networking::HostName((string)(from));
+}
+
+template <typename ConstBufferSequence>
+inline Windows::Storage::Streams::IBuffer^ buffer_dup(
+    const ConstBufferSequence& buffers)
+{
+  using Microsoft::WRL::ComPtr;
+  std::size_t size = boost::asio::buffer_size(buffers);
+  auto b = ref new Windows::Storage::Streams::Buffer(size);
+  ComPtr<IInspectable> insp = reinterpret_cast<IInspectable*>(b);
+  ComPtr<Windows::Storage::Streams::IBufferByteAccess> bacc;
+  insp.As(&bacc);
+  byte* bytes = nullptr;
+  bacc->Buffer(&bytes);
+  boost::asio::buffer_copy(boost::asio::buffer(bytes, size), buffers);
+  b->Length = size;
+  return b;
+}
+
+} // namespace winrt_utils
+} // namespace detail
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // defined(BOOST_ASIO_WINDOWS_RUNTIME)
+
+#endif // BOOST_ASIO_DETAIL_WINRT_UTILS_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/winsock_init.hpp b/3rdParty/Boost/src/boost/asio/detail/winsock_init.hpp
index 702ba71..aef74f0 100644
--- a/3rdParty/Boost/src/boost/asio/detail/winsock_init.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/winsock_init.hpp
@@ -1,11 +1,11 @@
 //
 // detail/winsock_init.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_WINSOCK_INIT_HPP
@@ -14,13 +14,13 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
@@ -36,14 +36,18 @@ protected:
     long result_;
   };
 
   BOOST_ASIO_DECL static void startup(data& d,
       unsigned char major, unsigned char minor);
 
+  BOOST_ASIO_DECL static void manual_startup(data& d);
+
   BOOST_ASIO_DECL static void cleanup(data& d);
 
+  BOOST_ASIO_DECL static void manual_cleanup(data& d);
+
   BOOST_ASIO_DECL static void throw_on_error(data& d);
 };
 
 template <int Major = 2, int Minor = 0>
 class winsock_init : private winsock_init_base
 {
@@ -63,13 +67,47 @@ public:
 
   ~winsock_init()
   {
     cleanup(data_);
   }
 
+  // This class may be used to indicate that user code will manage Winsock
+  // initialisation and cleanup. This may be required in the case of a DLL, for
+  // example, where it is not safe to initialise Winsock from global object
+  // constructors.
+  //
+  // To prevent asio from initialising Winsock, the object must be constructed
+  // before any Asio's own global objects. With MSVC, this may be accomplished
+  // by adding the following code to the DLL:
+  //
+  //   #pragma warning(push)
+  //   #pragma warning(disable:4073)
+  //   #pragma init_seg(lib)
+  //   boost::asio::detail::winsock_init<>::manual manual_winsock_init;
+  //   #pragma warning(pop)
+  class manual
+  {
+  public:
+    manual()
+    {
+      manual_startup(data_);
+    }
+
+    manual(const manual&)
+    {
+      manual_startup(data_);
+    }
+
+    ~manual()
+    {
+      manual_cleanup(data_);
+    }
+  };
+
 private:
+  friend class manual;
   static data data_;
 };
 
 template <int Major, int Minor>
 winsock_init_base::data winsock_init<Major, Minor>::data_;
 
@@ -84,9 +122,9 @@ static const winsock_init<>& winsock_init_instance = winsock_init<>(false);
 #include <boost/asio/detail/pop_options.hpp>
 
 #if defined(BOOST_ASIO_HEADER_ONLY)
 # include <boost/asio/detail/impl/winsock_init.ipp>
 #endif // defined(BOOST_ASIO_HEADER_ONLY)
 
-#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 
 #endif // BOOST_ASIO_DETAIL_WINSOCK_INIT_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/wrapped_handler.hpp b/3rdParty/Boost/src/boost/asio/detail/wrapped_handler.hpp
index d82da22..0ff28ed 100644
--- a/3rdParty/Boost/src/boost/asio/detail/wrapped_handler.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/wrapped_handler.hpp
@@ -1,11 +1,11 @@
 //
 // detail/wrapped_handler.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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_WRAPPED_HANDLER_HPP
@@ -14,21 +14,41 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #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/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
-template <typename Dispatcher, typename Handler>
+struct is_continuation_delegated
+{
+  template <typename Dispatcher, typename Handler>
+  bool operator()(Dispatcher&, Handler& handler) const
+  {
+    return boost_asio_handler_cont_helpers::is_continuation(handler);
+  }
+};
+
+struct is_continuation_if_running
+{
+  template <typename Dispatcher, typename Handler>
+  bool operator()(Dispatcher& dispatcher, Handler&) const
+  {
+    return dispatcher.running_in_this_thread();
+  }
+};
+
+template <typename Dispatcher, typename Handler,
+    typename IsContinuation = is_continuation_delegated>
 class wrapped_handler
 {
 public:
   typedef void result_type;
 
   wrapped_handler(Dispatcher dispatcher, Handler& handler)
@@ -50,13 +70,13 @@ public:
   {
   }
 #endif // defined(BOOST_ASIO_HAS_MOVE)
 
   void operator()()
   {
-    dispatcher_.dispatch(handler_);
+    dispatcher_.dispatch(BOOST_ASIO_MOVE_CAST(Handler)(handler_));
   }
 
   void operator()() const
   {
     dispatcher_.dispatch(handler_);
   }
@@ -178,40 +198,49 @@ public:
 
 //private:
   Context context_;
   Handler handler_;
 };
 
-template <typename Dispatcher, typename Handler>
+template <typename Dispatcher, typename Handler, typename IsContinuation>
 inline void* asio_handler_allocate(std::size_t size,
-    wrapped_handler<Dispatcher, Handler>* this_handler)
+    wrapped_handler<Dispatcher, Handler, IsContinuation>* this_handler)
 {
   return boost_asio_handler_alloc_helpers::allocate(
       size, this_handler->handler_);
 }
 
-template <typename Dispatcher, typename Handler>
+template <typename Dispatcher, typename Handler, typename IsContinuation>
 inline void asio_handler_deallocate(void* pointer, std::size_t size,
-    wrapped_handler<Dispatcher, Handler>* this_handler)
+    wrapped_handler<Dispatcher, Handler, IsContinuation>* this_handler)
 {
   boost_asio_handler_alloc_helpers::deallocate(
       pointer, size, this_handler->handler_);
 }
 
-template <typename Function, typename Dispatcher, typename Handler>
+template <typename Dispatcher, typename Handler, typename IsContinuation>
+inline bool asio_handler_is_continuation(
+    wrapped_handler<Dispatcher, Handler, IsContinuation>* this_handler)
+{
+  return IsContinuation()(this_handler->dispatcher_, this_handler->handler_);
+}
+
+template <typename Function, typename Dispatcher,
+    typename Handler, typename IsContinuation>
 inline void asio_handler_invoke(Function& function,
-    wrapped_handler<Dispatcher, Handler>* this_handler)
+    wrapped_handler<Dispatcher, Handler, IsContinuation>* this_handler)
 {
   this_handler->dispatcher_.dispatch(
       rewrapped_handler<Function, Handler>(
         function, this_handler->handler_));
 }
 
-template <typename Function, typename Dispatcher, typename Handler>
+template <typename Function, typename Dispatcher,
+    typename Handler, typename IsContinuation>
 inline void asio_handler_invoke(const Function& function,
-    wrapped_handler<Dispatcher, Handler>* this_handler)
+    wrapped_handler<Dispatcher, Handler, IsContinuation>* this_handler)
 {
   this_handler->dispatcher_.dispatch(
       rewrapped_handler<Function, Handler>(
         function, this_handler->handler_));
 }
 
@@ -228,12 +257,20 @@ inline void asio_handler_deallocate(void* pointer, std::size_t size,
     rewrapped_handler<Handler, Context>* this_handler)
 {
   boost_asio_handler_alloc_helpers::deallocate(
       pointer, size, this_handler->context_);
 }
 
+template <typename Dispatcher, typename Context>
+inline bool asio_handler_is_continuation(
+    rewrapped_handler<Dispatcher, Context>* this_handler)
+{
+  return boost_asio_handler_cont_helpers::is_continuation(
+      this_handler->context_);
+}
+
 template <typename Function, typename Handler, typename Context>
 inline void asio_handler_invoke(Function& function,
     rewrapped_handler<Handler, Context>* this_handler)
 {
   boost_asio_handler_invoke_helpers::invoke(
       function, this_handler->context_);
diff --git a/3rdParty/Boost/src/boost/asio/error.hpp b/3rdParty/Boost/src/boost/asio/error.hpp
index 331297b..7bcc00f 100644
--- a/3rdParty/Boost/src/boost/asio/error.hpp
+++ b/3rdParty/Boost/src/boost/asio/error.hpp
@@ -1,11 +1,11 @@
 //
 // error.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)
 //
 
 #ifndef BOOST_ASIO_ERROR_HPP
@@ -15,13 +15,16 @@
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 #include <boost/cerrno.hpp>
 #include <boost/system/error_code.hpp>
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#include <boost/system/system_error.hpp>
+#if defined(BOOST_ASIO_WINDOWS) \
+  || defined(__CYGWIN__) \
+  || defined(BOOST_ASIO_WINDOWS_RUNTIME)
 # include <winerror.h>
 #else
 # include <cerrno>
 # include <netdb.h>
 #endif
 
@@ -33,13 +36,19 @@
 /// INTERNAL ONLY.
 # define BOOST_ASIO_NETDB_ERROR(e) implementation_defined
 /// INTERNAL ONLY.
 # define BOOST_ASIO_GETADDRINFO_ERROR(e) implementation_defined
 /// INTERNAL ONLY.
 # define BOOST_ASIO_WIN_OR_POSIX(e_win, e_posix) implementation_defined
-#elif defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#elif defined(BOOST_ASIO_WINDOWS_RUNTIME)
+# define BOOST_ASIO_NATIVE_ERROR(e) __HRESULT_FROM_WIN32(e)
+# define BOOST_ASIO_SOCKET_ERROR(e) __HRESULT_FROM_WIN32(WSA ## e)
+# define BOOST_ASIO_NETDB_ERROR(e) __HRESULT_FROM_WIN32(WSA ## e)
+# define BOOST_ASIO_GETADDRINFO_ERROR(e) __HRESULT_FROM_WIN32(WSA ## e)
+# define BOOST_ASIO_WIN_OR_POSIX(e_win, e_posix) e_win
+#elif defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 # define BOOST_ASIO_NATIVE_ERROR(e) e
 # define BOOST_ASIO_SOCKET_ERROR(e) WSA ## e
 # define BOOST_ASIO_NETDB_ERROR(e) WSA ## e
 # define BOOST_ASIO_GETADDRINFO_ERROR(e) WSA ## e
 # define BOOST_ASIO_WIN_OR_POSIX(e_win, e_posix) e_win
 #else
@@ -213,33 +222,33 @@ enum misc_errors
 
 inline const boost::system::error_category& get_system_category()
 {
   return boost::system::system_category();
 }
 
-#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+#if !defined(BOOST_ASIO_WINDOWS) && !defined(__CYGWIN__)
 
 extern BOOST_ASIO_DECL
 const boost::system::error_category& get_netdb_category();
 
 extern BOOST_ASIO_DECL
 const boost::system::error_category& get_addrinfo_category();
 
-#else // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+#else // !defined(BOOST_ASIO_WINDOWS) && !defined(__CYGWIN__)
 
 inline const boost::system::error_category& get_netdb_category()
 {
   return get_system_category();
 }
 
 inline const boost::system::error_category& get_addrinfo_category()
 {
   return get_system_category();
 }
 
-#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+#endif // !defined(BOOST_ASIO_WINDOWS) && !defined(__CYGWIN__)
 
 extern BOOST_ASIO_DECL
 const boost::system::error_category& get_misc_category();
 
 static const boost::system::error_category& system_category
   = boost::asio::error::get_system_category();
diff --git a/3rdParty/Boost/src/boost/asio/generic/basic_endpoint.hpp b/3rdParty/Boost/src/boost/asio/generic/basic_endpoint.hpp
new file mode 100644
index 0000000..bb6344d
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/generic/basic_endpoint.hpp
@@ -0,0 +1,195 @@
+//
+// generic/basic_endpoint.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_GENERIC_BASIC_ENDPOINT_HPP
+#define BOOST_ASIO_GENERIC_BASIC_ENDPOINT_HPP
+
+#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/generic/detail/endpoint.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace generic {
+
+/// Describes an endpoint for any socket type.
+/**
+ * The boost::asio::generic::basic_endpoint class template describes an endpoint
+ * that may be associated with any socket type.
+ *
+ * @note The socket types sockaddr type must be able to fit into a
+ * @c sockaddr_storage structure.
+ *
+ * @par Thread Safety
+ * @e Distinct @e objects: Safe.@n
+ * @e Shared @e objects: Unsafe.
+ *
+ * @par Concepts:
+ * Endpoint.
+ */
+template <typename Protocol>
+class basic_endpoint
+{
+public:
+  /// The protocol type associated with the endpoint.
+  typedef Protocol protocol_type;
+
+  /// The type of the endpoint structure. This type is dependent on the
+  /// underlying implementation of the socket layer.
+#if defined(GENERATING_DOCUMENTATION)
+  typedef implementation_defined data_type;
+#else
+  typedef boost::asio::detail::socket_addr_type data_type;
+#endif
+
+  /// Default constructor.
+  basic_endpoint()
+  {
+  }
+
+  /// Construct an endpoint from the specified socket address.
+  basic_endpoint(const void* socket_address,
+      std::size_t socket_address_size, int socket_protocol = 0)
+    : impl_(socket_address, socket_address_size, socket_protocol)
+  {
+  }
+
+  /// Construct an endpoint from the specific endpoint type.
+  template <typename Endpoint>
+  basic_endpoint(const Endpoint& endpoint)
+    : impl_(endpoint.data(), endpoint.size(), endpoint.protocol().protocol())
+  {
+  }
+
+  /// Copy constructor.
+  basic_endpoint(const basic_endpoint& other)
+    : impl_(other.impl_)
+  {
+  }
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+  /// Move constructor.
+  basic_endpoint(basic_endpoint&& other)
+    : impl_(other.impl_)
+  {
+  }
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
+  /// Assign from another endpoint.
+  basic_endpoint& operator=(const basic_endpoint& other)
+  {
+    impl_ = other.impl_;
+    return *this;
+  }
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+  /// Move-assign from another endpoint.
+  basic_endpoint& operator=(basic_endpoint&& other)
+  {
+    impl_ = other.impl_;
+    return *this;
+  }
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
+  /// The protocol associated with the endpoint.
+  protocol_type protocol() const
+  {
+    return protocol_type(impl_.family(), impl_.protocol());
+  }
+
+  /// Get the underlying endpoint in the native type.
+  data_type* data()
+  {
+    return impl_.data();
+  }
+
+  /// Get the underlying endpoint in the native type.
+  const data_type* data() const
+  {
+    return impl_.data();
+  }
+
+  /// Get the underlying size of the endpoint in the native type.
+  std::size_t size() const
+  {
+    return impl_.size();
+  }
+
+  /// Set the underlying size of the endpoint in the native type.
+  void resize(std::size_t new_size)
+  {
+    impl_.resize(new_size);
+  }
+
+  /// Get the capacity of the endpoint in the native type.
+  std::size_t capacity() const
+  {
+    return impl_.capacity();
+  }
+
+  /// Compare two endpoints for equality.
+  friend bool operator==(const basic_endpoint<Protocol>& e1,
+      const basic_endpoint<Protocol>& e2)
+  {
+    return e1.impl_ == e2.impl_;
+  }
+
+  /// Compare two endpoints for inequality.
+  friend bool operator!=(const basic_endpoint<Protocol>& e1,
+      const basic_endpoint<Protocol>& e2)
+  {
+    return !(e1.impl_ == e2.impl_);
+  }
+
+  /// Compare endpoints for ordering.
+  friend bool operator<(const basic_endpoint<Protocol>& e1,
+      const basic_endpoint<Protocol>& e2)
+  {
+    return e1.impl_ < e2.impl_;
+  }
+
+  /// Compare endpoints for ordering.
+  friend bool operator>(const basic_endpoint<Protocol>& e1,
+      const basic_endpoint<Protocol>& e2)
+  {
+    return e2.impl_ < e1.impl_;
+  }
+
+  /// Compare endpoints for ordering.
+  friend bool operator<=(const basic_endpoint<Protocol>& e1,
+      const basic_endpoint<Protocol>& e2)
+  {
+    return !(e2 < e1);
+  }
+
+  /// Compare endpoints for ordering.
+  friend bool operator>=(const basic_endpoint<Protocol>& e1,
+      const basic_endpoint<Protocol>& e2)
+  {
+    return !(e1 < e2);
+  }
+
+private:
+  // The underlying generic endpoint.
+  boost::asio::generic::detail::endpoint impl_;
+};
+
+} // namespace generic
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_GENERIC_BASIC_ENDPOINT_HPP
diff --git a/3rdParty/Boost/src/boost/asio/generic/datagram_protocol.hpp b/3rdParty/Boost/src/boost/asio/generic/datagram_protocol.hpp
new file mode 100644
index 0000000..48fa36d
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/generic/datagram_protocol.hpp
@@ -0,0 +1,125 @@
+//
+// generic/datagram_protocol.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_GENERIC_DATAGRAM_PROTOCOL_HPP
+#define BOOST_ASIO_GENERIC_DATAGRAM_PROTOCOL_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#include <typeinfo>
+#include <boost/asio/basic_datagram_socket.hpp>
+#include <boost/asio/detail/socket_types.hpp>
+#include <boost/asio/detail/throw_exception.hpp>
+#include <boost/asio/generic/basic_endpoint.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace generic {
+
+/// Encapsulates the flags needed for a generic datagram-oriented socket.
+/**
+ * The boost::asio::generic::datagram_protocol class contains flags necessary
+ * for datagram-oriented sockets of any address family and protocol.
+ *
+ * @par Examples
+ * Constructing using a native address family and socket protocol:
+ * @code datagram_protocol p(AF_INET, IPPROTO_UDP); @endcode
+ * Constructing from a specific protocol type:
+ * @code datagram_protocol p(boost::asio::ip::udp::v4()); @endcode
+ *
+ * @par Thread Safety
+ * @e Distinct @e objects: Safe.@n
+ * @e Shared @e objects: Safe.
+ *
+ * @par Concepts:
+ * Protocol.
+ */
+class datagram_protocol
+{
+public:
+  /// Construct a protocol object for a specific address family and protocol.
+  datagram_protocol(int address_family, int socket_protocol)
+    : family_(address_family),
+      protocol_(socket_protocol)
+  {
+  }
+
+  /// Construct a generic protocol object from a specific protocol.
+  /**
+   * @throws @c bad_cast Thrown if the source protocol is not datagram-oriented.
+   */
+  template <typename Protocol>
+  datagram_protocol(const Protocol& source_protocol)
+    : family_(source_protocol.family()),
+      protocol_(source_protocol.protocol())
+  {
+    if (source_protocol.type() != type())
+    {
+      std::bad_cast ex;
+      boost::asio::detail::throw_exception(ex);
+    }
+  }
+
+  /// Obtain an identifier for the type of the protocol.
+  int type() const
+  {
+    return BOOST_ASIO_OS_DEF(SOCK_DGRAM);
+  }
+
+  /// Obtain an identifier for the protocol.
+  int protocol() const
+  {
+    return protocol_;
+  }
+
+  /// Obtain an identifier for the protocol family.
+  int family() const
+  {
+    return family_;
+  }
+
+  /// Compare two protocols for equality.
+  friend bool operator==(const datagram_protocol& p1,
+      const datagram_protocol& p2)
+  {
+    return p1.family_ == p2.family_ && p1.protocol_ == p2.protocol_;
+  }
+
+  /// Compare two protocols for inequality.
+  friend bool operator!=(const datagram_protocol& p1,
+      const datagram_protocol& p2)
+  {
+    return !(p1 == p2);
+  }
+
+  /// The type of an endpoint.
+  typedef basic_endpoint<datagram_protocol> endpoint;
+
+  /// The generic socket type.
+  typedef basic_datagram_socket<datagram_protocol> socket;
+
+private:
+  int family_;
+  int protocol_;
+};
+
+} // namespace generic
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_GENERIC_DATAGRAM_PROTOCOL_HPP
diff --git a/3rdParty/Boost/src/boost/asio/generic/detail/endpoint.hpp b/3rdParty/Boost/src/boost/asio/generic/detail/endpoint.hpp
new file mode 100644
index 0000000..3f5437d
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/generic/detail/endpoint.hpp
@@ -0,0 +1,135 @@
+//
+// generic/detail/endpoint.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_GENERIC_DETAIL_ENDPOINT_HPP
+#define BOOST_ASIO_GENERIC_DETAIL_ENDPOINT_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#include <cstddef>
+#include <boost/asio/detail/socket_types.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace generic {
+namespace detail {
+
+// Helper class for implementing a generic socket endpoint.
+class endpoint
+{
+public:
+  // Default constructor.
+  BOOST_ASIO_DECL endpoint();
+
+  // Construct an endpoint from the specified raw bytes.
+  BOOST_ASIO_DECL endpoint(const void* sock_addr,
+      std::size_t sock_addr_size, int sock_protocol);
+
+  // Copy constructor.
+  endpoint(const endpoint& other)
+    : data_(other.data_),
+      size_(other.size_),
+      protocol_(other.protocol_)
+  {
+  }
+
+  // Assign from another endpoint.
+  endpoint& operator=(const endpoint& other)
+  {
+    data_ = other.data_;
+    size_ = other.size_;
+    protocol_ = other.protocol_;
+    return *this;
+  }
+
+  // Get the address family associated with the endpoint.
+  int family() const
+  {
+    return data_.base.sa_family;
+  }
+
+  // Get the socket protocol associated with the endpoint.
+  int protocol() const
+  {
+    return protocol_;
+  }
+
+  // Get the underlying endpoint in the native type.
+  boost::asio::detail::socket_addr_type* data()
+  {
+    return &data_.base;
+  }
+
+  // Get the underlying endpoint in the native type.
+  const boost::asio::detail::socket_addr_type* data() const
+  {
+    return &data_.base;
+  }
+
+  // Get the underlying size of the endpoint in the native type.
+  std::size_t size() const
+  {
+    return size_;
+  }
+
+  // Set the underlying size of the endpoint in the native type.
+  BOOST_ASIO_DECL void resize(std::size_t size);
+
+  // Get the capacity of the endpoint in the native type.
+  std::size_t capacity() const
+  {
+    return sizeof(boost::asio::detail::sockaddr_storage_type);
+  }
+
+  // Compare two endpoints for equality.
+  BOOST_ASIO_DECL friend bool operator==(
+      const endpoint& e1, const endpoint& e2);
+
+  // Compare endpoints for ordering.
+  BOOST_ASIO_DECL friend bool operator<(
+      const endpoint& e1, const endpoint& e2);
+
+private:
+  // The underlying socket address.
+  union data_union
+  {
+    boost::asio::detail::socket_addr_type base;
+    boost::asio::detail::sockaddr_storage_type generic;
+  } data_;
+
+  // The length of the socket address stored in the endpoint.
+  std::size_t size_;
+
+  // The socket protocol associated with the endpoint.
+  int protocol_;
+
+  // Initialise with a specified memory.
+  BOOST_ASIO_DECL void init(const void* sock_addr,
+      std::size_t sock_addr_size, int sock_protocol);
+};
+
+} // namespace detail
+} // namespace generic
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#if defined(BOOST_ASIO_HEADER_ONLY)
+# include <boost/asio/generic/detail/impl/endpoint.ipp>
+#endif // defined(BOOST_ASIO_HEADER_ONLY)
+
+#endif // BOOST_ASIO_GENERIC_DETAIL_ENDPOINT_HPP
diff --git a/3rdParty/Boost/src/boost/asio/generic/detail/impl/endpoint.ipp b/3rdParty/Boost/src/boost/asio/generic/detail/impl/endpoint.ipp
new file mode 100644
index 0000000..af049ca
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/generic/detail/impl/endpoint.ipp
@@ -0,0 +1,111 @@
+//
+// generic/detail/impl/endpoint.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_GENERIC_DETAIL_IMPL_ENDPOINT_IPP
+#define BOOST_ASIO_GENERIC_DETAIL_IMPL_ENDPOINT_IPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#include <cstring>
+#include <typeinfo>
+#include <boost/asio/detail/socket_ops.hpp>
+#include <boost/asio/detail/throw_error.hpp>
+#include <boost/asio/detail/throw_exception.hpp>
+#include <boost/asio/error.hpp>
+#include <boost/asio/generic/detail/endpoint.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace generic {
+namespace detail {
+
+endpoint::endpoint()
+{
+  init(0, 0, 0);
+}
+
+endpoint::endpoint(const void* sock_addr,
+    std::size_t sock_addr_size, int sock_protocol)
+{
+  init(sock_addr, sock_addr_size, sock_protocol);
+}
+
+void endpoint::resize(std::size_t new_size)
+{
+  if (new_size > sizeof(boost::asio::detail::sockaddr_storage_type))
+  {
+    boost::system::error_code ec(boost::asio::error::invalid_argument);
+    boost::asio::detail::throw_error(ec);
+  }
+  else
+  {
+    size_ = new_size;
+    protocol_ = 0;
+  }
+}
+
+bool operator==(const endpoint& e1, const endpoint& e2)
+{
+  using namespace std; // For memcmp.
+  return e1.size() == e2.size() && memcmp(e1.data(), e2.data(), e1.size()) == 0;
+}
+
+bool operator<(const endpoint& e1, const endpoint& e2)
+{
+  if (e1.protocol() < e2.protocol())
+    return true;
+
+  if (e1.protocol() > e2.protocol())
+    return false;
+
+  using namespace std; // For memcmp.
+  std::size_t compare_size = e1.size() < e2.size() ? e1.size() : e2.size();
+  int compare_result = memcmp(e1.data(), e2.data(), compare_size);
+
+  if (compare_result < 0)
+    return true;
+
+  if (compare_result > 0)
+    return false;
+
+  return e1.size() < e2.size();
+}
+
+void endpoint::init(const void* sock_addr,
+    std::size_t sock_addr_size, int sock_protocol)
+{
+  if (sock_addr_size > sizeof(boost::asio::detail::sockaddr_storage_type))
+  {
+    boost::system::error_code ec(boost::asio::error::invalid_argument);
+    boost::asio::detail::throw_error(ec);
+  }
+
+  using namespace std; // For memset and memcpy.
+  memset(&data_.generic, 0, sizeof(boost::asio::detail::sockaddr_storage_type));
+  memcpy(&data_.generic, sock_addr, sock_addr_size);
+
+  size_ = sock_addr_size;
+  protocol_ = sock_protocol;
+}
+
+} // namespace detail
+} // namespace generic
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_GENERIC_DETAIL_IMPL_ENDPOINT_IPP
diff --git a/3rdParty/Boost/src/boost/asio/generic/raw_protocol.hpp b/3rdParty/Boost/src/boost/asio/generic/raw_protocol.hpp
new file mode 100644
index 0000000..bb1b1a4
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/generic/raw_protocol.hpp
@@ -0,0 +1,123 @@
+//
+// generic/raw_protocol.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_GENERIC_RAW_PROTOCOL_HPP
+#define BOOST_ASIO_GENERIC_RAW_PROTOCOL_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#include <typeinfo>
+#include <boost/asio/basic_raw_socket.hpp>
+#include <boost/asio/detail/socket_types.hpp>
+#include <boost/asio/detail/throw_exception.hpp>
+#include <boost/asio/generic/basic_endpoint.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace generic {
+
+/// Encapsulates the flags needed for a generic raw socket.
+/**
+ * The boost::asio::generic::raw_protocol class contains flags necessary for
+ * raw sockets of any address family and protocol.
+ *
+ * @par Examples
+ * Constructing using a native address family and socket protocol:
+ * @code raw_protocol p(AF_INET, IPPROTO_ICMP); @endcode
+ * Constructing from a specific protocol type:
+ * @code raw_protocol p(boost::asio::ip::icmp::v4()); @endcode
+ *
+ * @par Thread Safety
+ * @e Distinct @e objects: Safe.@n
+ * @e Shared @e objects: Safe.
+ *
+ * @par Concepts:
+ * Protocol.
+ */
+class raw_protocol
+{
+public:
+  /// Construct a protocol object for a specific address family and protocol.
+  raw_protocol(int address_family, int socket_protocol)
+    : family_(address_family),
+      protocol_(socket_protocol)
+  {
+  }
+
+  /// Construct a generic protocol object from a specific protocol.
+  /**
+   * @throws @c bad_cast Thrown if the source protocol is not raw-oriented.
+   */
+  template <typename Protocol>
+  raw_protocol(const Protocol& source_protocol)
+    : family_(source_protocol.family()),
+      protocol_(source_protocol.protocol())
+  {
+    if (source_protocol.type() != type())
+    {
+      std::bad_cast ex;
+      boost::asio::detail::throw_exception(ex);
+    }
+  }
+
+  /// Obtain an identifier for the type of the protocol.
+  int type() const
+  {
+    return BOOST_ASIO_OS_DEF(SOCK_RAW);
+  }
+
+  /// Obtain an identifier for the protocol.
+  int protocol() const
+  {
+    return protocol_;
+  }
+
+  /// Obtain an identifier for the protocol family.
+  int family() const
+  {
+    return family_;
+  }
+
+  /// Compare two protocols for equality.
+  friend bool operator==(const raw_protocol& p1, const raw_protocol& p2)
+  {
+    return p1.family_ == p2.family_ && p1.protocol_ == p2.protocol_;
+  }
+
+  /// Compare two protocols for inequality.
+  friend bool operator!=(const raw_protocol& p1, const raw_protocol& p2)
+  {
+    return !(p1 == p2);
+  }
+
+  /// The type of an endpoint.
+  typedef basic_endpoint<raw_protocol> endpoint;
+
+  /// The generic socket type.
+  typedef basic_raw_socket<raw_protocol> socket;
+
+private:
+  int family_;
+  int protocol_;
+};
+
+} // namespace generic
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_GENERIC_RAW_PROTOCOL_HPP
diff --git a/3rdParty/Boost/src/boost/asio/generic/seq_packet_protocol.hpp b/3rdParty/Boost/src/boost/asio/generic/seq_packet_protocol.hpp
new file mode 100644
index 0000000..2a17b80
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/generic/seq_packet_protocol.hpp
@@ -0,0 +1,124 @@
+//
+// generic/seq_packet_protocol.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_GENERIC_SEQ_PACKET_PROTOCOL_HPP
+#define BOOST_ASIO_GENERIC_SEQ_PACKET_PROTOCOL_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#include <typeinfo>
+#include <boost/asio/basic_seq_packet_socket.hpp>
+#include <boost/asio/detail/socket_types.hpp>
+#include <boost/asio/detail/throw_exception.hpp>
+#include <boost/asio/generic/basic_endpoint.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace generic {
+
+/// Encapsulates the flags needed for a generic sequenced packet socket.
+/**
+ * The boost::asio::generic::seq_packet_protocol class contains flags necessary
+ * for seq_packet-oriented sockets of any address family and protocol.
+ *
+ * @par Examples
+ * Constructing using a native address family and socket protocol:
+ * @code seq_packet_protocol p(AF_INET, IPPROTO_SCTP); @endcode
+ *
+ * @par Thread Safety
+ * @e Distinct @e objects: Safe.@n
+ * @e Shared @e objects: Safe.
+ *
+ * @par Concepts:
+ * Protocol.
+ */
+class seq_packet_protocol
+{
+public:
+  /// Construct a protocol object for a specific address family and protocol.
+  seq_packet_protocol(int address_family, int socket_protocol)
+    : family_(address_family),
+      protocol_(socket_protocol)
+  {
+  }
+
+  /// Construct a generic protocol object from a specific protocol.
+  /**
+   * @throws @c bad_cast Thrown if the source protocol is not based around
+   * sequenced packets.
+   */
+  template <typename Protocol>
+  seq_packet_protocol(const Protocol& source_protocol)
+    : family_(source_protocol.family()),
+      protocol_(source_protocol.protocol())
+  {
+    if (source_protocol.type() != type())
+    {
+      std::bad_cast ex;
+      boost::asio::detail::throw_exception(ex);
+    }
+  }
+
+  /// Obtain an identifier for the type of the protocol.
+  int type() const
+  {
+    return BOOST_ASIO_OS_DEF(SOCK_SEQPACKET);
+  }
+
+  /// Obtain an identifier for the protocol.
+  int protocol() const
+  {
+    return protocol_;
+  }
+
+  /// Obtain an identifier for the protocol family.
+  int family() const
+  {
+    return family_;
+  }
+
+  /// Compare two protocols for equality.
+  friend bool operator==(const seq_packet_protocol& p1,
+      const seq_packet_protocol& p2)
+  {
+    return p1.family_ == p2.family_ && p1.protocol_ == p2.protocol_;
+  }
+
+  /// Compare two protocols for inequality.
+  friend bool operator!=(const seq_packet_protocol& p1,
+      const seq_packet_protocol& p2)
+  {
+    return !(p1 == p2);
+  }
+
+  /// The type of an endpoint.
+  typedef basic_endpoint<seq_packet_protocol> endpoint;
+
+  /// The generic socket type.
+  typedef basic_seq_packet_socket<seq_packet_protocol> socket;
+
+private:
+  int family_;
+  int protocol_;
+};
+
+} // namespace generic
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_GENERIC_SEQ_PACKET_PROTOCOL_HPP
diff --git a/3rdParty/Boost/src/boost/asio/generic/stream_protocol.hpp b/3rdParty/Boost/src/boost/asio/generic/stream_protocol.hpp
new file mode 100644
index 0000000..1ec89b9
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/generic/stream_protocol.hpp
@@ -0,0 +1,129 @@
+//
+// generic/stream_protocol.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_GENERIC_STREAM_PROTOCOL_HPP
+#define BOOST_ASIO_GENERIC_STREAM_PROTOCOL_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#include <typeinfo>
+#include <boost/asio/basic_socket_iostream.hpp>
+#include <boost/asio/basic_stream_socket.hpp>
+#include <boost/asio/detail/socket_types.hpp>
+#include <boost/asio/detail/throw_exception.hpp>
+#include <boost/asio/generic/basic_endpoint.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace generic {
+
+/// Encapsulates the flags needed for a generic stream-oriented socket.
+/**
+ * The boost::asio::generic::stream_protocol class contains flags necessary for
+ * stream-oriented sockets of any address family and protocol.
+ *
+ * @par Examples
+ * Constructing using a native address family and socket protocol:
+ * @code stream_protocol p(AF_INET, IPPROTO_TCP); @endcode
+ * Constructing from a specific protocol type:
+ * @code stream_protocol p(boost::asio::ip::tcp::v4()); @endcode
+ *
+ * @par Thread Safety
+ * @e Distinct @e objects: Safe.@n
+ * @e Shared @e objects: Safe.
+ *
+ * @par Concepts:
+ * Protocol.
+ */
+class stream_protocol
+{
+public:
+  /// Construct a protocol object for a specific address family and protocol.
+  stream_protocol(int address_family, int socket_protocol)
+    : family_(address_family),
+      protocol_(socket_protocol)
+  {
+  }
+
+  /// Construct a generic protocol object from a specific protocol.
+  /**
+   * @throws @c bad_cast Thrown if the source protocol is not stream-oriented.
+   */
+  template <typename Protocol>
+  stream_protocol(const Protocol& source_protocol)
+    : family_(source_protocol.family()),
+      protocol_(source_protocol.protocol())
+  {
+    if (source_protocol.type() != type())
+    {
+      std::bad_cast ex;
+      boost::asio::detail::throw_exception(ex);
+    }
+  }
+
+  /// Obtain an identifier for the type of the protocol.
+  int type() const
+  {
+    return BOOST_ASIO_OS_DEF(SOCK_STREAM);
+  }
+
+  /// Obtain an identifier for the protocol.
+  int protocol() const
+  {
+    return protocol_;
+  }
+
+  /// Obtain an identifier for the protocol family.
+  int family() const
+  {
+    return family_;
+  }
+
+  /// Compare two protocols for equality.
+  friend bool operator==(const stream_protocol& p1, const stream_protocol& p2)
+  {
+    return p1.family_ == p2.family_ && p1.protocol_ == p2.protocol_;
+  }
+
+  /// Compare two protocols for inequality.
+  friend bool operator!=(const stream_protocol& p1, const stream_protocol& p2)
+  {
+    return !(p1 == p2);
+  }
+
+  /// The type of an endpoint.
+  typedef basic_endpoint<stream_protocol> endpoint;
+
+  /// The generic socket type.
+  typedef basic_stream_socket<stream_protocol> socket;
+
+#if !defined(BOOST_ASIO_NO_IOSTREAM)
+  /// The generic socket iostream type.
+  typedef basic_socket_iostream<stream_protocol> iostream;
+#endif // !defined(BOOST_ASIO_NO_IOSTREAM)
+
+private:
+  int family_;
+  int protocol_;
+};
+
+} // namespace generic
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_GENERIC_STREAM_PROTOCOL_HPP
diff --git a/3rdParty/Boost/src/boost/asio/handler_alloc_hook.hpp b/3rdParty/Boost/src/boost/asio/handler_alloc_hook.hpp
index 6bef151..ed8956d 100644
--- a/3rdParty/Boost/src/boost/asio/handler_alloc_hook.hpp
+++ b/3rdParty/Boost/src/boost/asio/handler_alloc_hook.hpp
@@ -1,11 +1,11 @@
 //
 // handler_alloc_hook.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)
 //
 
 #ifndef BOOST_ASIO_HANDLER_ALLOC_HOOK_HPP
@@ -29,16 +29,14 @@ namespace asio {
  * asynchronous operations have a handler function object, these temporary
  * objects can be said to be associated with the handler.
  *
  * Implement asio_handler_allocate and asio_handler_deallocate for your own
  * handlers to provide custom allocation for these temporary objects.
  *
- * This default implementation is simply:
- * @code
- * return ::operator new(size);
- * @endcode
+ * The default implementation of these allocation hooks uses <tt>::operator
+ * new</tt> and <tt>::operator delete</tt>.
  *
  * @note All temporary objects associated with a handler will be deallocated
  * before the upcall to the handler is performed. This allows the same memory to
  * be reused for a subsequent asynchronous operation initiated by the handler.
  *
  * @par Example
@@ -54,35 +52,32 @@ namespace asio {
  *     my_handler* context)
  * {
  *   ::operator delete(pointer);
  * }
  * @endcode
  */
-inline void* asio_handler_allocate(std::size_t size, ...)
-{
-  return ::operator new(size);
-}
+BOOST_ASIO_DECL void* asio_handler_allocate(
+    std::size_t size, ...);
 
 /// Default deallocation function for handlers.
 /**
  * Implement asio_handler_allocate and asio_handler_deallocate for your own
  * handlers to provide custom allocation for the associated temporary objects.
  *
- * This default implementation is simply:
- * @code
- * ::operator delete(pointer);
- * @endcode
+ * The default implementation of these allocation hooks uses <tt>::operator
+ * new</tt> and <tt>::operator delete</tt>.
  *
  * @sa asio_handler_allocate.
  */
-inline void asio_handler_deallocate(void* pointer, std::size_t size, ...)
-{
-  (void)(size);
-  ::operator delete(pointer);
-}
+BOOST_ASIO_DECL void asio_handler_deallocate(
+    void* pointer, std::size_t size, ...);
 
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
+#if defined(BOOST_ASIO_HEADER_ONLY)
+# include <boost/asio/impl/handler_alloc_hook.ipp>
+#endif // defined(BOOST_ASIO_HEADER_ONLY)
+
 #endif // BOOST_ASIO_HANDLER_ALLOC_HOOK_HPP
diff --git a/3rdParty/Boost/src/boost/asio/handler_continuation_hook.hpp b/3rdParty/Boost/src/boost/asio/handler_continuation_hook.hpp
new file mode 100644
index 0000000..929b855
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/handler_continuation_hook.hpp
@@ -0,0 +1,56 @@
+//
+// handler_continuation_hook.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_HANDLER_CONTINUATION_HOOK_HPP
+#define BOOST_ASIO_HANDLER_CONTINUATION_HOOK_HPP
+
+#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/push_options.hpp>
+
+namespace boost {
+namespace asio {
+
+/// Default continuation function for handlers.
+/**
+ * Asynchronous operations may represent a continuation of the asynchronous
+ * control flow associated with the current handler. The implementation can use
+ * this knowledge to optimise scheduling of the handler.
+ *
+ * Implement asio_handler_is_continuation for your own handlers to indicate
+ * when a handler represents a continuation.
+ *
+ * The default implementation of the continuation hook returns <tt>false</tt>.
+ *
+ * @par Example
+ * @code
+ * class my_handler;
+ *
+ * bool asio_handler_is_continuation(my_handler* context)
+ * {
+ *   return true;
+ * }
+ * @endcode
+ */
+inline bool asio_handler_is_continuation(...)
+{
+  return false;
+}
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_HANDLER_CONTINUATION_HOOK_HPP
diff --git a/3rdParty/Boost/src/boost/asio/handler_invoke_hook.hpp b/3rdParty/Boost/src/boost/asio/handler_invoke_hook.hpp
index 6f03888..e81b51a 100644
--- a/3rdParty/Boost/src/boost/asio/handler_invoke_hook.hpp
+++ b/3rdParty/Boost/src/boost/asio/handler_invoke_hook.hpp
@@ -1,11 +1,11 @@
 //
 // handler_invoke_hook.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)
 //
 
 #ifndef BOOST_ASIO_HANDLER_INVOKE_HOOK_HPP
@@ -19,14 +19,16 @@
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 
-/// Default invoke function for handlers.
-/**
+/** @defgroup asio_handler_invoke boost::asio::asio_handler_invoke
+ *
+ * @brief Default invoke function for handlers.
+ *
  * Completion handlers for asynchronous operations are invoked by the
  * io_service associated with the corresponding object (e.g. a socket or
  * deadline_timer). Certain guarantees are made on when the handler may be
  * invoked, in particular that a handler can only be invoked from a thread that
  * is currently calling @c run() on the corresponding io_service object.
  * Handlers may subsequently be invoked through other objects (such as
@@ -39,34 +41,47 @@ namespace asio {
  * hooking function ensures that the invoked method used for the final handler
  * is accessible at each intermediate step.
  *
  * Implement asio_handler_invoke for your own handlers to specify a custom
  * invocation strategy.
  *
- * This default implementation is simply:
- * @code
- * function();
- * @endcode
+ * This default implementation invokes the function object like so:
+ * @code function(); @endcode
+ * If necessary, the default implementation makes a copy of the function object
+ * so that the non-const operator() can be used.
  *
  * @par Example
  * @code
  * class my_handler;
  *
  * template <typename Function>
  * void asio_handler_invoke(Function function, my_handler* context)
  * {
  *   context->strand_.dispatch(function);
  * }
  * @endcode
  */
+/*@{*/
+
+/// Default handler invocation hook used for non-const function objects.
 template <typename Function>
-inline void asio_handler_invoke(Function function, ...)
+inline void asio_handler_invoke(Function& function, ...)
 {
   function();
 }
 
+/// Default handler invocation hook used for const function objects.
+template <typename Function>
+inline void asio_handler_invoke(const Function& function, ...)
+{
+  Function tmp(function);
+  tmp();
+}
+
+/*@}*/
+
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // BOOST_ASIO_HANDLER_INVOKE_HOOK_HPP
diff --git a/3rdParty/Boost/src/boost/asio/handler_type.hpp b/3rdParty/Boost/src/boost/asio/handler_type.hpp
new file mode 100644
index 0000000..a933f6b
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/handler_type.hpp
@@ -0,0 +1,114 @@
+//
+// handler_type.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_HANDLER_TYPE_HPP
+#define BOOST_ASIO_HANDLER_TYPE_HPP
+
+#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/push_options.hpp>
+
+namespace boost {
+namespace asio {
+
+/// Default handler type traits provided for all handlers.
+/**
+ * The handler_type traits class is used for determining the concrete handler
+ * type to be used for an asynchronous operation. It allows the handler type to
+ * be determined at the point where the specific completion handler signature
+ * is known.
+ *
+ * This template may be specialised for user-defined handler types.
+ */
+template <typename Handler, typename Signature>
+struct handler_type
+{
+  /// The handler type for the specific signature.
+  typedef Handler type;
+};
+
+#if !defined(GENERATING_DOCUMENTATION)
+
+template <typename Handler, typename Signature>
+struct handler_type<const Handler, Signature>
+  : handler_type<Handler, Signature> {};
+
+template <typename Handler, typename Signature>
+struct handler_type<volatile Handler, Signature>
+  : handler_type<Handler, Signature> {};
+
+template <typename Handler, typename Signature>
+struct handler_type<const volatile Handler, Signature>
+  : handler_type<Handler, Signature> {};
+
+template <typename Handler, typename Signature>
+struct handler_type<const Handler&, Signature>
+  : handler_type<Handler, Signature> {};
+
+template <typename Handler, typename Signature>
+struct handler_type<volatile Handler&, Signature>
+  : handler_type<Handler, Signature> {};
+
+template <typename Handler, typename Signature>
+struct handler_type<const volatile Handler&, Signature>
+  : handler_type<Handler, Signature> {};
+
+template <typename Handler, typename Signature>
+struct handler_type<Handler&, Signature>
+  : handler_type<Handler, Signature> {};
+
+#if defined(BOOST_ASIO_HAS_MOVE)
+template <typename Handler, typename Signature>
+struct handler_type<Handler&&, Signature>
+  : handler_type<Handler, Signature> {};
+#endif // defined(BOOST_ASIO_HAS_MOVE)
+
+template <typename ReturnType, typename Signature>
+struct handler_type<ReturnType(), Signature>
+  : handler_type<ReturnType(*)(), Signature> {};
+
+template <typename ReturnType, typename Arg1, typename Signature>
+struct handler_type<ReturnType(Arg1), Signature>
+  : handler_type<ReturnType(*)(Arg1), Signature> {};
+
+template <typename ReturnType, typename Arg1, typename Arg2, typename Signature>
+struct handler_type<ReturnType(Arg1, Arg2), Signature>
+  : handler_type<ReturnType(*)(Arg1, Arg2), Signature> {};
+
+template <typename ReturnType, typename Arg1, typename Arg2, typename Arg3,
+    typename Signature>
+struct handler_type<ReturnType(Arg1, Arg2, Arg3), Signature>
+  : handler_type<ReturnType(*)(Arg1, Arg2, Arg3), Signature> {};
+
+template <typename ReturnType, typename Arg1, typename Arg2, typename Arg3,
+    typename Arg4, typename Signature>
+struct handler_type<ReturnType(Arg1, Arg2, Arg3, Arg4), Signature>
+  : handler_type<ReturnType(*)(Arg1, Arg2, Arg3, Arg4), Signature> {};
+
+template <typename ReturnType, typename Arg1, typename Arg2, typename Arg3,
+    typename Arg4, typename Arg5, typename Signature>
+struct handler_type<ReturnType(Arg1, Arg2, Arg3, Arg4, Arg5), Signature>
+  : handler_type<ReturnType(*)(Arg1, Arg2, Arg3, Arg4, Arg5), Signature> {};
+
+#endif // !defined(GENERATING_DOCUMENTATION)
+
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#define BOOST_ASIO_HANDLER_TYPE(h, sig) \
+  typename handler_type<h, sig>::type
+
+#endif // BOOST_ASIO_HANDLER_TYPE_HPP
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
@@ -1,11 +1,11 @@
 //
 // 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)
 //
 
 #ifndef BOOST_ASIO_IMPL_CONNECT_HPP
@@ -15,12 +15,13 @@
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #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>
 #include <boost/asio/error.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
@@ -181,39 +182,42 @@ namespace detail
         const ConnectCondition& connect_condition,
         ComposedConnectHandler& handler)
       : base_from_connect_condition<ConnectCondition>(connect_condition),
         socket_(sock),
         iter_(begin),
         end_(end),
+        start_(0),
         handler_(BOOST_ASIO_MOVE_CAST(ComposedConnectHandler)(handler))
     {
     }
 
 #if defined(BOOST_ASIO_HAS_MOVE)
     connect_op(const connect_op& other)
       : base_from_connect_condition<ConnectCondition>(other),
         socket_(other.socket_),
         iter_(other.iter_),
         end_(other.end_),
+        start_(other.start_),
         handler_(other.handler_)
     {
     }
 
     connect_op(connect_op&& other)
       : base_from_connect_condition<ConnectCondition>(other),
         socket_(other.socket_),
         iter_(other.iter_),
         end_(other.end_),
+        start_(other.start_),
         handler_(BOOST_ASIO_MOVE_CAST(ComposedConnectHandler)(other.handler_))
     {
     }
 #endif // defined(BOOST_ASIO_HAS_MOVE)
 
     void operator()(boost::system::error_code ec, int start = 0)
     {
-      switch (start)
+      switch (start_ = start)
       {
         case 1:
         for (;;)
         {
           this->check_condition(ec, iter_, end_);
 
@@ -255,12 +259,13 @@ namespace detail
     }
 
   //private:
     basic_socket<Protocol, SocketService>& socket_;
     Iterator iter_;
     Iterator end_;
+    int start_;
     ComposedConnectHandler handler_;
   };
 
   template <typename Protocol, typename SocketService, typename Iterator,
       typename ConnectCondition, typename ComposedConnectHandler>
   inline void* asio_handler_allocate(std::size_t size,
@@ -278,12 +283,22 @@ namespace detail
         ConnectCondition, ComposedConnectHandler>* this_handler)
   {
     boost_asio_handler_alloc_helpers::deallocate(
         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>
   inline void asio_handler_invoke(Function& function,
       connect_op<Protocol, SocketService, Iterator,
         ConnectCondition, ComposedConnectHandler>* this_handler)
@@ -299,91 +314,115 @@ namespace detail
       connect_op<Protocol, SocketService, Iterator,
         ConnectCondition, ComposedConnectHandler>* this_handler)
   {
     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
   // not meet the documented type requirements for a ComposedConnectHandler.
   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)
 {
   // If you get an error on the following line it means that your handler does
   // not meet the documented type requirements for a ComposedConnectHandler.
   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)
 {
   // If you get an error on the following line it means that your handler does
   // not meet the documented type requirements for a ComposedConnectHandler.
   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)
 {
   // If you get an error on the following line it means that your handler does
   // not meet the documented type requirements for a ComposedConnectHandler.
   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
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
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
@@ -1,11 +1,11 @@
 //
 // 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)
 //
 
 #ifndef BOOST_ASIO_IMPL_ERROR_IPP
@@ -13,28 +13,29 @@
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #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>
 
 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";
   }
 
   std::string message(int value) const
   {
@@ -60,13 +61,13 @@ const boost::system::error_category& get_netdb_category()
 
 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";
   }
 
   std::string message(int value) const
   {
@@ -83,20 +84,20 @@ public:
 const boost::system::error_category& get_addrinfo_category()
 {
   static detail::addrinfo_category instance;
   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";
   }
 
   std::string message(int value) const
   {
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
@@ -1,11 +1,11 @@
 //
 // 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)
 //
 
 #ifndef BOOST_ASIO_IMPL_IO_SERVICE_HPP
@@ -74,30 +74,43 @@ inline bool has_service(io_service& ios)
 #include <boost/asio/detail/push_options.hpp>
 
 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>
 #if defined(GENERATING_DOCUMENTATION)
 unspecified
 #else
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
@@ -1,11 +1,11 @@
 //
 // 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)
 //
 
 #ifndef BOOST_ASIO_IMPL_IO_SERVICE_IPP
@@ -13,14 +13,14 @@
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #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>
 
 #if defined(BOOST_ASIO_HAS_IOCP)
 # include <boost/asio/detail/win_iocp_io_service.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
@@ -1,11 +1,11 @@
 //
 // 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)
 //
 
 #ifndef BOOST_ASIO_IMPL_READ_HPP
@@ -21,12 +21,13 @@
 #include <boost/asio/detail/array_fwd.hpp>
 #include <boost/asio/detail/base_from_completion_cond.hpp>
 #include <boost/asio/detail/bind_handler.hpp>
 #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>
 #include <boost/asio/error.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
@@ -80,13 +81,13 @@ inline std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
   boost::system::error_code ec;
   std::size_t bytes_transferred = read(s, buffers, completion_condition, ec);
   boost::asio::detail::throw_error(ec, "read");
   return bytes_transferred;
 }
 
-#if !defined(BOOST_NO_IOSTREAM)
+#if !defined(BOOST_ASIO_NO_IOSTREAM)
 
 template <typename SyncReadStream, typename Allocator,
     typename CompletionCondition>
 std::size_t read(SyncReadStream& s,
     boost::asio::basic_streambuf<Allocator>& b,
     CompletionCondition completion_condition, boost::system::error_code& ec)
@@ -135,13 +136,13 @@ inline std::size_t read(SyncReadStream& s,
   boost::system::error_code ec;
   std::size_t bytes_transferred = read(s, b, completion_condition, ec);
   boost::asio::detail::throw_error(ec, "read");
   return bytes_transferred;
 }
 
-#endif // !defined(BOOST_NO_IOSTREAM)
+#endif // !defined(BOOST_ASIO_NO_IOSTREAM)
 
 namespace detail
 {
   template <typename AsyncReadStream, typename MutableBufferSequence,
       typename CompletionCondition, typename ReadHandler>
   class read_op
@@ -151,41 +152,44 @@ namespace detail
     read_op(AsyncReadStream& stream, const MutableBufferSequence& buffers,
         CompletionCondition completion_condition, ReadHandler& handler)
       : detail::base_from_completion_cond<
           CompletionCondition>(completion_condition),
         stream_(stream),
         buffers_(buffers),
+        start_(0),
         total_transferred_(0),
         handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))
     {
     }
 
 #if defined(BOOST_ASIO_HAS_MOVE)
     read_op(const read_op& other)
       : detail::base_from_completion_cond<CompletionCondition>(other),
         stream_(other.stream_),
         buffers_(other.buffers_),
+        start_(other.start_),
         total_transferred_(other.total_transferred_),
         handler_(other.handler_)
     {
     }
 
     read_op(read_op&& other)
       : 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_))
     {
     }
 #endif // defined(BOOST_ASIO_HAS_MOVE)
 
     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_));
         for (;;)
         {
           stream_.async_read_some(buffers_,
@@ -204,12 +208,13 @@ namespace detail
     }
 
   //private:
     AsyncReadStream& stream_;
     boost::asio::detail::consuming_buffers<
       mutable_buffer, MutableBufferSequence> buffers_;
+    int start_;
     std::size_t total_transferred_;
     ReadHandler handler_;
   };
 
   template <typename AsyncReadStream,
       typename CompletionCondition, typename ReadHandler>
@@ -222,42 +227,45 @@ namespace detail
         const boost::asio::mutable_buffers_1& buffers,
         CompletionCondition completion_condition, ReadHandler& handler)
       : detail::base_from_completion_cond<
           CompletionCondition>(completion_condition),
         stream_(stream),
         buffer_(buffers),
+        start_(0),
         total_transferred_(0),
         handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))
     {
     }
 
 #if defined(BOOST_ASIO_HAS_MOVE)
     read_op(const read_op& other)
       : detail::base_from_completion_cond<CompletionCondition>(other),
         stream_(other.stream_),
         buffer_(other.buffer_),
+        start_(other.start_),
         total_transferred_(other.total_transferred_),
         handler_(other.handler_)
     {
     }
 
     read_op(read_op&& other)
       : 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_))
     {
     }
 #endif // defined(BOOST_ASIO_HAS_MOVE)
 
     void operator()(const boost::system::error_code& ec,
         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_);
         for (;;)
         {
           stream_.async_read_some(
@@ -275,12 +283,13 @@ namespace detail
       }
     }
 
   //private:
     AsyncReadStream& stream_;
     boost::asio::mutable_buffer buffer_;
+    int start_;
     std::size_t total_transferred_;
     ReadHandler handler_;
   };
 
   template <typename AsyncReadStream, typename Elem,
       typename CompletionCondition, typename ReadHandler>
@@ -292,31 +301,34 @@ namespace detail
     read_op(AsyncReadStream& stream, const boost::array<Elem, 2>& buffers,
         CompletionCondition completion_condition, ReadHandler& handler)
       : detail::base_from_completion_cond<
           CompletionCondition>(completion_condition),
         stream_(stream),
         buffers_(buffers),
+        start_(0),
         total_transferred_(0),
         handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))
     {
     }
 
 #if defined(BOOST_ASIO_HAS_MOVE)
     read_op(const read_op& other)
       : detail::base_from_completion_cond<CompletionCondition>(other),
         stream_(other.stream_),
         buffers_(other.buffers_),
+        start_(other.start_),
         total_transferred_(other.total_transferred_),
         handler_(other.handler_)
     {
     }
 
     read_op(read_op&& other)
       : 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_))
     {
     }
 #endif // defined(BOOST_ASIO_HAS_MOVE)
 
@@ -327,13 +339,13 @@ namespace detail
           boost::array<boost::asio::mutable_buffer, 2> >::type bufs = {{
         boost::asio::mutable_buffer(buffers_[0]),
         boost::asio::mutable_buffer(buffers_[1]) }};
       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_);
         for (;;)
         {
           bufs[0] = boost::asio::buffer(bufs[0] + total_transferred_, n);
@@ -354,12 +366,13 @@ namespace detail
       }
     }
 
   //private:
     AsyncReadStream& stream_;
     boost::array<Elem, 2> buffers_;
+    int start_;
     std::size_t total_transferred_;
     ReadHandler handler_;
   };
 
 #if defined(BOOST_ASIO_HAS_STD_ARRAY)
 
@@ -373,31 +386,34 @@ namespace detail
     read_op(AsyncReadStream& stream, const std::array<Elem, 2>& buffers,
         CompletionCondition completion_condition, ReadHandler& handler)
       : detail::base_from_completion_cond<
           CompletionCondition>(completion_condition),
         stream_(stream),
         buffers_(buffers),
+        start_(0),
         total_transferred_(0),
         handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))
     {
     }
 
 #if defined(BOOST_ASIO_HAS_MOVE)
     read_op(const read_op& other)
       : detail::base_from_completion_cond<CompletionCondition>(other),
         stream_(other.stream_),
         buffers_(other.buffers_),
+        start_(other.start_),
         total_transferred_(other.total_transferred_),
         handler_(other.handler_)
     {
     }
 
     read_op(read_op&& other)
       : 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_))
     {
     }
 #endif // defined(BOOST_ASIO_HAS_MOVE)
 
@@ -408,13 +424,13 @@ namespace detail
           std::array<boost::asio::mutable_buffer, 2> >::type bufs = {{
         boost::asio::mutable_buffer(buffers_[0]),
         boost::asio::mutable_buffer(buffers_[1]) }};
       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_);
         for (;;)
         {
           bufs[0] = boost::asio::buffer(bufs[0] + total_transferred_, n);
@@ -435,12 +451,13 @@ namespace detail
       }
     }
 
   //private:
     AsyncReadStream& stream_;
     std::array<Elem, 2> buffers_;
+    int start_;
     std::size_t total_transferred_;
     ReadHandler handler_;
   };
 
 #endif // defined(BOOST_ASIO_HAS_STD_ARRAY)
 
@@ -461,12 +478,23 @@ namespace detail
         CompletionCondition, ReadHandler>* this_handler)
   {
     boost_asio_handler_alloc_helpers::deallocate(
         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>
   inline void asio_handler_invoke(Function& function,
       read_op<AsyncReadStream, MutableBufferSequence,
         CompletionCondition, ReadHandler>* this_handler)
@@ -482,56 +510,64 @@ namespace detail
       read_op<AsyncReadStream, MutableBufferSequence,
         CompletionCondition, ReadHandler>* this_handler)
   {
     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)
 {
   // 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, 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
 {
   template <typename AsyncReadStream, typename Allocator,
       typename CompletionCondition, typename ReadHandler>
   class read_streambuf_op
@@ -542,42 +578,45 @@ namespace detail
         basic_streambuf<Allocator>& streambuf,
         CompletionCondition completion_condition, ReadHandler& handler)
       : detail::base_from_completion_cond<
           CompletionCondition>(completion_condition),
         stream_(stream),
         streambuf_(streambuf),
+        start_(0),
         total_transferred_(0),
         handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))
     {
     }
 
 #if defined(BOOST_ASIO_HAS_MOVE)
     read_streambuf_op(const read_streambuf_op& other)
       : detail::base_from_completion_cond<CompletionCondition>(other),
         stream_(other.stream_),
         streambuf_(other.streambuf_),
+        start_(other.start_),
         total_transferred_(other.total_transferred_),
         handler_(other.handler_)
     {
     }
 
     read_streambuf_op(read_streambuf_op&& other)
       : 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_))
     {
     }
 #endif // defined(BOOST_ASIO_HAS_MOVE)
 
     void operator()(const boost::system::error_code& ec,
         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_);
         bytes_available = read_size_helper(streambuf_, max_size);
         for (;;)
         {
@@ -596,12 +635,13 @@ namespace detail
       }
     }
 
   //private:
     AsyncReadStream& stream_;
     boost::asio::basic_streambuf<Allocator>& streambuf_;
+    int start_;
     std::size_t total_transferred_;
     ReadHandler handler_;
   };
 
   template <typename AsyncReadStream, typename Allocator,
       typename CompletionCondition, typename ReadHandler>
@@ -620,12 +660,23 @@ namespace detail
         CompletionCondition, ReadHandler>* this_handler)
   {
     boost_asio_handler_alloc_helpers::deallocate(
         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,
       read_streambuf_op<AsyncReadStream, Allocator,
         CompletionCondition, ReadHandler>* this_handler)
   {
@@ -639,57 +690,65 @@ namespace detail
       read_streambuf_op<AsyncReadStream, Allocator,
         CompletionCondition, ReadHandler>* this_handler)
   {
     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)
 {
   // 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_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)
 {
   // 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_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
 
 #include <boost/asio/detail/pop_options.hpp>
 
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
@@ -1,11 +1,11 @@
 //
 // 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)
 //
 
 #ifndef BOOST_ASIO_IMPL_READ_AT_HPP
@@ -21,12 +21,13 @@
 #include <boost/asio/detail/array_fwd.hpp>
 #include <boost/asio/detail/base_from_completion_cond.hpp>
 #include <boost/asio/detail/bind_handler.hpp>
 #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>
 #include <boost/asio/error.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
@@ -34,13 +35,13 @@
 namespace boost {
 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();
   boost::asio::detail::consuming_buffers<
     mutable_buffer, MutableBufferSequence> tmp(buffers);
   std::size_t total_transferred = 0;
@@ -57,48 +58,48 @@ std::size_t read_at(SyncRandomAccessReadDevice& d,
   }
   return total_transferred;
 }
 
 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(
       d, offset, buffers, transfer_all(), ec);
   boost::asio::detail::throw_error(ec, "read_at");
   return bytes_transferred;
 }
 
 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);
 }
 
 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;
   std::size_t bytes_transferred = read_at(
       d, offset, buffers, completion_condition, ec);
   boost::asio::detail::throw_error(ec, "read_at");
   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();
   std::size_t total_transferred = 0;
   std::size_t max_size = detail::adapt_completion_condition_result(
         completion_condition(ec, total_transferred));
@@ -115,92 +116,95 @@ std::size_t read_at(SyncRandomAccessReadDevice& d,
   }
   return total_transferred;
 }
 
 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(
       d, offset, b, transfer_all(), ec);
   boost::asio::detail::throw_error(ec, "read_at");
   return bytes_transferred;
 }
 
 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);
 }
 
 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;
   std::size_t bytes_transferred = read_at(
       d, offset, b, completion_condition, ec);
   boost::asio::detail::throw_error(ec, "read_at");
   return bytes_transferred;
 }
 
-#endif // !defined(BOOST_NO_IOSTREAM)
+#endif // !defined(BOOST_ASIO_NO_IOSTREAM)
 
 namespace detail
 {
   template <typename AsyncRandomAccessReadDevice,
       typename MutableBufferSequence, typename CompletionCondition,
       typename ReadHandler>
   class read_at_op
     : detail::base_from_completion_cond<CompletionCondition>
   {
   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))
     {
     }
 
 #if defined(BOOST_ASIO_HAS_MOVE)
     read_at_op(const read_at_op& other)
       : detail::base_from_completion_cond<CompletionCondition>(other),
         device_(other.device_),
         offset_(other.offset_),
         buffers_(other.buffers_),
+        start_(other.start_),
         total_transferred_(other.total_transferred_),
         handler_(other.handler_)
     {
     }
 
     read_at_op(read_at_op&& other)
       : detail::base_from_completion_cond<CompletionCondition>(other),
         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_))
     {
     }
 #endif // defined(BOOST_ASIO_HAS_MOVE)
 
     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_));
         for (;;)
         {
           device_.async_read_some_at(offset_ + total_transferred_,
@@ -217,66 +221,70 @@ namespace detail
         handler_(ec, static_cast<const std::size_t&>(total_transferred_));
       }
     }
 
   //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_;
   };
 
   template <typename AsyncRandomAccessReadDevice,
       typename CompletionCondition, typename ReadHandler>
   class read_at_op<AsyncRandomAccessReadDevice,
       boost::asio::mutable_buffers_1, CompletionCondition, ReadHandler>
     : detail::base_from_completion_cond<CompletionCondition>
   {
   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))
     {
     }
 
 #if defined(BOOST_ASIO_HAS_MOVE)
     read_at_op(const read_at_op& other)
       : detail::base_from_completion_cond<CompletionCondition>(other),
         device_(other.device_),
         offset_(other.offset_),
         buffer_(other.buffer_),
+        start_(other.start_),
         total_transferred_(other.total_transferred_),
         handler_(other.handler_)
     {
     }
 
     read_at_op(read_at_op&& other)
       : detail::base_from_completion_cond<CompletionCondition>(other),
         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_))
     {
     }
 #endif // defined(BOOST_ASIO_HAS_MOVE)
 
     void operator()(const boost::system::error_code& ec,
         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_);
         for (;;)
         {
           device_.async_read_some_at(offset_ + total_transferred_,
@@ -293,54 +301,58 @@ namespace detail
         handler_(ec, static_cast<const std::size_t&>(total_transferred_));
       }
     }
 
   //private:
     AsyncRandomAccessReadDevice& device_;
-    boost::uint64_t offset_;
+    uint64_t offset_;
     boost::asio::mutable_buffer buffer_;
+    int start_;
     std::size_t total_transferred_;
     ReadHandler handler_;
   };
 
   template <typename AsyncRandomAccessReadDevice, typename Elem,
       typename CompletionCondition, typename ReadHandler>
   class read_at_op<AsyncRandomAccessReadDevice, boost::array<Elem, 2>,
       CompletionCondition, ReadHandler>
     : detail::base_from_completion_cond<CompletionCondition>
   {
   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))
     {
     }
 
 #if defined(BOOST_ASIO_HAS_MOVE)
     read_at_op(const read_at_op& other)
       : detail::base_from_completion_cond<CompletionCondition>(other),
         device_(other.device_),
         offset_(other.offset_),
         buffers_(other.buffers_),
+        start_(other.start_),
         total_transferred_(other.total_transferred_),
         handler_(other.handler_)
     {
     }
 
     read_at_op(read_at_op&& other)
       : detail::base_from_completion_cond<CompletionCondition>(other),
         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_))
     {
     }
 #endif // defined(BOOST_ASIO_HAS_MOVE)
 
@@ -351,13 +363,13 @@ namespace detail
           boost::array<boost::asio::mutable_buffer, 2> >::type bufs = {{
         boost::asio::mutable_buffer(buffers_[0]),
         boost::asio::mutable_buffer(buffers_[1]) }};
       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_);
         for (;;)
         {
           bufs[0] = boost::asio::buffer(bufs[0] + total_transferred_, n);
@@ -378,14 +390,15 @@ namespace detail
         handler_(ec, static_cast<const std::size_t&>(total_transferred_));
       }
     }
 
   //private:
     AsyncRandomAccessReadDevice& device_;
-    boost::uint64_t offset_;
+    uint64_t offset_;
     boost::array<Elem, 2> buffers_;
+    int start_;
     std::size_t total_transferred_;
     ReadHandler handler_;
   };
 
 #if defined(BOOST_ASIO_HAS_STD_ARRAY)
 
@@ -394,40 +407,43 @@ namespace detail
   class read_at_op<AsyncRandomAccessReadDevice, std::array<Elem, 2>,
       CompletionCondition, ReadHandler>
     : detail::base_from_completion_cond<CompletionCondition>
   {
   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))
     {
     }
 
 #if defined(BOOST_ASIO_HAS_MOVE)
     read_at_op(const read_at_op& other)
       : detail::base_from_completion_cond<CompletionCondition>(other),
         device_(other.device_),
         offset_(other.offset_),
         buffers_(other.buffers_),
+        start_(other.start_),
         total_transferred_(other.total_transferred_),
         handler_(other.handler_)
     {
     }
 
     read_at_op(read_at_op&& other)
       : detail::base_from_completion_cond<CompletionCondition>(other),
         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_))
     {
     }
 #endif // defined(BOOST_ASIO_HAS_MOVE)
 
@@ -438,13 +454,13 @@ namespace detail
           std::array<boost::asio::mutable_buffer, 2> >::type bufs = {{
         boost::asio::mutable_buffer(buffers_[0]),
         boost::asio::mutable_buffer(buffers_[1]) }};
       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_);
         for (;;)
         {
           bufs[0] = boost::asio::buffer(bufs[0] + total_transferred_, n);
@@ -465,14 +481,15 @@ namespace detail
         handler_(ec, static_cast<const std::size_t&>(total_transferred_));
       }
     }
 
   //private:
     AsyncRandomAccessReadDevice& device_;
-    boost::uint64_t offset_;
+    uint64_t offset_;
     std::array<Elem, 2> buffers_;
+    int start_;
     std::size_t total_transferred_;
     ReadHandler handler_;
   };
 
 #endif // defined(BOOST_ASIO_HAS_STD_ARRAY)
 
@@ -495,12 +512,24 @@ namespace detail
         CompletionCondition, ReadHandler>* this_handler)
   {
     boost_asio_handler_alloc_helpers::deallocate(
         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>
   inline void asio_handler_invoke(Function& function,
       read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence,
         CompletionCondition, ReadHandler>* this_handler)
@@ -523,104 +552,125 @@ namespace detail
   template <typename AsyncRandomAccessReadDevice,
       typename MutableBufferSequence, typename CompletionCondition,
       typename ReadHandler>
   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,
       MutableBufferSequence, CompletionCondition, ReadHandler>(
         d, offset, buffers, completion_condition, handler);
   }
 } // 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)
 {
   // 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, 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
 {
   template <typename AsyncRandomAccessReadDevice, typename Allocator,
       typename CompletionCondition, typename ReadHandler>
   class read_at_streambuf_op
     : detail::base_from_completion_cond<CompletionCondition>
   {
   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))
     {
     }
 
 #if defined(BOOST_ASIO_HAS_MOVE)
     read_at_streambuf_op(const read_at_streambuf_op& other)
       : detail::base_from_completion_cond<CompletionCondition>(other),
         device_(other.device_),
         offset_(other.offset_),
         streambuf_(other.streambuf_),
+        start_(other.start_),
         total_transferred_(other.total_transferred_),
         handler_(other.handler_)
     {
     }
 
     read_at_streambuf_op(read_at_streambuf_op&& other)
       : detail::base_from_completion_cond<CompletionCondition>(other),
         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_))
     {
     }
 #endif // defined(BOOST_ASIO_HAS_MOVE)
 
     void operator()(const boost::system::error_code& ec,
         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_);
         bytes_available = read_size_helper(streambuf_, max_size);
         for (;;)
         {
@@ -639,14 +689,15 @@ namespace detail
         handler_(ec, static_cast<const std::size_t&>(total_transferred_));
       }
     }
 
   //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_;
   };
 
   template <typename AsyncRandomAccessReadDevice, typename Allocator,
       typename CompletionCondition, typename ReadHandler>
@@ -665,12 +716,23 @@ namespace detail
         CompletionCondition, ReadHandler>* this_handler)
   {
     boost_asio_handler_alloc_helpers::deallocate(
         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,
       read_at_streambuf_op<AsyncRandomAccessReadDevice, Allocator,
         CompletionCondition, ReadHandler>* this_handler)
   {
@@ -684,61 +746,66 @@ namespace detail
       read_at_streambuf_op<AsyncRandomAccessReadDevice, Allocator,
         CompletionCondition, ReadHandler>* this_handler)
   {
     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)
 {
   // 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, 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
 
 #include <boost/asio/detail/pop_options.hpp>
 
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
@@ -1,11 +1,11 @@
 //
 // 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)
 //
 
 #ifndef BOOST_ASIO_IMPL_READ_UNTIL_HPP
@@ -16,19 +16,20 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <algorithm>
 #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>
 
 namespace boost {
 namespace asio {
@@ -186,12 +187,14 @@ std::size_t read_until(SyncReadStream& s,
     b.commit(s.read_some(b.prepare(bytes_to_read), ec));
     if (ec)
       return 0;
   }
 }
 
+#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)
 {
   boost::system::error_code ec;
   std::size_t bytes_transferred = read_until(s, b, expr, ec);
@@ -253,17 +256,19 @@ std::size_t read_until(SyncReadStream& s,
     b.commit(s.read_some(b.prepare(bytes_to_read), ec));
     if (ec)
       return 0;
   }
 }
 
+#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 (;;)
   {
     // Determine the range of the data to be searched.
     typedef typename boost::asio::basic_streambuf<
@@ -308,13 +313,13 @@ 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);
   boost::asio::detail::throw_error(ec, "read_until");
   return bytes_transferred;
 }
@@ -328,43 +333,46 @@ namespace detail
     read_until_delim_op(AsyncReadStream& stream,
         boost::asio::basic_streambuf<Allocator>& streambuf,
         char delim, ReadHandler& handler)
       : stream_(stream),
         streambuf_(streambuf),
         delim_(delim),
+        start_(0),
         search_position_(0),
         handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))
     {
     }
 
 #if defined(BOOST_ASIO_HAS_MOVE)
     read_until_delim_op(const read_until_delim_op& other)
       : stream_(other.stream_),
         streambuf_(other.streambuf_),
         delim_(other.delim_),
+        start_(other.start_),
         search_position_(other.search_position_),
         handler_(other.handler_)
     {
     }
 
     read_until_delim_op(read_until_delim_op&& other)
       : 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_))
     {
     }
 #endif // defined(BOOST_ASIO_HAS_MOVE)
 
     void operator()(const boost::system::error_code& ec,
         std::size_t bytes_transferred, int start = 0)
     {
       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 (;;)
         {
           {
             // Determine the range of the data to be searched.
@@ -427,12 +435,13 @@ namespace detail
     }
 
   //private:
     AsyncReadStream& stream_;
     boost::asio::basic_streambuf<Allocator>& streambuf_;
     char delim_;
+    int start_;
     std::size_t search_position_;
     ReadHandler handler_;
   };
 
   template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
   inline void* asio_handler_allocate(std::size_t size,
@@ -449,12 +458,22 @@ namespace detail
         Allocator, ReadHandler>* this_handler)
   {
     boost_asio_handler_alloc_helpers::deallocate(
         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,
       read_until_delim_op<AsyncReadStream,
         Allocator, ReadHandler>* this_handler)
   {
@@ -468,36 +487,36 @@ namespace detail
       read_until_delim_op<AsyncReadStream,
         Allocator, ReadHandler>* this_handler)
   {
     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)
 {
   // 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_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
 {
   template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
   class read_until_delim_string_op
@@ -506,43 +525,46 @@ namespace detail
     read_until_delim_string_op(AsyncReadStream& stream,
         boost::asio::basic_streambuf<Allocator>& streambuf,
         const std::string& delim, ReadHandler& handler)
       : stream_(stream),
         streambuf_(streambuf),
         delim_(delim),
+        start_(0),
         search_position_(0),
         handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))
     {
     }
 
 #if defined(BOOST_ASIO_HAS_MOVE)
     read_until_delim_string_op(const read_until_delim_string_op& other)
       : stream_(other.stream_),
         streambuf_(other.streambuf_),
         delim_(other.delim_),
+        start_(other.start_),
         search_position_(other.search_position_),
         handler_(other.handler_)
     {
     }
 
     read_until_delim_string_op(read_until_delim_string_op&& other)
       : 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_))
     {
     }
 #endif // defined(BOOST_ASIO_HAS_MOVE)
 
     void operator()(const boost::system::error_code& ec,
         std::size_t bytes_transferred, int start = 0)
     {
       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 (;;)
         {
           {
             // Determine the range of the data to be searched.
@@ -616,12 +638,13 @@ namespace detail
     }
 
   //private:
     AsyncReadStream& stream_;
     boost::asio::basic_streambuf<Allocator>& streambuf_;
     std::string delim_;
+    int start_;
     std::size_t search_position_;
     ReadHandler handler_;
   };
 
   template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
   inline void* asio_handler_allocate(std::size_t size,
@@ -638,12 +661,22 @@ namespace detail
         Allocator, ReadHandler>* this_handler)
   {
     boost_asio_handler_alloc_helpers::deallocate(
         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,
       read_until_delim_string_op<AsyncReadStream,
         Allocator, ReadHandler>* this_handler)
   {
@@ -657,38 +690,40 @@ namespace detail
       read_until_delim_string_op<AsyncReadStream,
         Allocator, ReadHandler>* this_handler)
   {
     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)
 {
   // 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_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,
       typename RegEx, typename ReadHandler>
   class read_until_expr_op
   {
@@ -696,43 +731,46 @@ namespace detail
     read_until_expr_op(AsyncReadStream& stream,
         boost::asio::basic_streambuf<Allocator>& streambuf,
         const boost::regex& expr, ReadHandler& handler)
       : stream_(stream),
         streambuf_(streambuf),
         expr_(expr),
+        start_(0),
         search_position_(0),
         handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))
     {
     }
 
 #if defined(BOOST_ASIO_HAS_MOVE)
     read_until_expr_op(const read_until_expr_op& other)
       : stream_(other.stream_),
         streambuf_(other.streambuf_),
         expr_(other.expr_),
+        start_(other.start_),
         search_position_(other.search_position_),
         handler_(other.handler_)
     {
     }
 
     read_until_expr_op(read_until_expr_op&& other)
       : 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_))
     {
     }
 #endif // defined(BOOST_ASIO_HAS_MOVE)
 
     void operator()(const boost::system::error_code& ec,
         std::size_t bytes_transferred, int start = 0)
     {
       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 (;;)
         {
           {
             // Determine the range of the data to be searched.
@@ -809,12 +847,13 @@ namespace detail
     }
 
   //private:
     AsyncReadStream& stream_;
     boost::asio::basic_streambuf<Allocator>& streambuf_;
     RegEx expr_;
+    int start_;
     std::size_t search_position_;
     ReadHandler handler_;
   };
 
   template <typename AsyncReadStream, typename Allocator,
       typename RegEx, typename ReadHandler>
@@ -833,12 +872,23 @@ namespace detail
         Allocator, RegEx, ReadHandler>* this_handler)
   {
     boost_asio_handler_alloc_helpers::deallocate(
         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,
       read_until_expr_op<AsyncReadStream,
         Allocator, RegEx, ReadHandler>* this_handler)
   {
@@ -852,39 +902,40 @@ namespace detail
       read_until_expr_op<AsyncReadStream,
         Allocator, RegEx, ReadHandler>* this_handler)
   {
     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)
 {
   // 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_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,
       typename MatchCondition, typename ReadHandler>
   class read_until_match_op
   {
@@ -892,43 +943,46 @@ namespace detail
     read_until_match_op(AsyncReadStream& stream,
         boost::asio::basic_streambuf<Allocator>& streambuf,
         MatchCondition match_condition, ReadHandler& handler)
       : stream_(stream),
         streambuf_(streambuf),
         match_condition_(match_condition),
+        start_(0),
         search_position_(0),
         handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))
     {
     }
 
 #if defined(BOOST_ASIO_HAS_MOVE)
     read_until_match_op(const read_until_match_op& other)
       : stream_(other.stream_),
         streambuf_(other.streambuf_),
         match_condition_(other.match_condition_),
+        start_(other.start_),
         search_position_(other.search_position_),
         handler_(other.handler_)
     {
     }
 
     read_until_match_op(read_until_match_op&& other)
       : 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_))
     {
     }
 #endif // defined(BOOST_ASIO_HAS_MOVE)
 
     void operator()(const boost::system::error_code& ec,
         std::size_t bytes_transferred, int start = 0)
     {
       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 (;;)
         {
           {
             // Determine the range of the data to be searched.
@@ -1001,12 +1055,13 @@ namespace detail
     }
 
   //private:
     AsyncReadStream& stream_;
     boost::asio::basic_streambuf<Allocator>& streambuf_;
     MatchCondition match_condition_;
+    int start_;
     std::size_t search_position_;
     ReadHandler handler_;
   };
 
   template <typename AsyncReadStream, typename Allocator,
       typename MatchCondition, typename ReadHandler>
@@ -1025,12 +1080,23 @@ namespace detail
         Allocator, MatchCondition, ReadHandler>* this_handler)
   {
     boost_asio_handler_alloc_helpers::deallocate(
         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,
       read_until_match_op<AsyncReadStream,
         Allocator, MatchCondition, ReadHandler>* this_handler)
   {
@@ -1044,41 +1110,38 @@ namespace detail
       read_until_match_op<AsyncReadStream,
         Allocator, MatchCondition, ReadHandler>* this_handler)
   {
     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
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
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
@@ -1,11 +1,11 @@
 //
 // 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
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 //
 
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
@@ -1,11 +1,11 @@
 //
 // 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
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 //
 
@@ -18,19 +18,19 @@
 
 #include <boost/asio/detail/config.hpp>
 
 #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
 #endif
 
 #include <boost/asio/detail/push_options.hpp>
@@ -38,13 +38,13 @@
 namespace boost {
 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;
   switch (value_)
   {
   // Do POSIX-specified rates first.
@@ -108,13 +108,12 @@ boost::system::error_code serial_port_base::baud_rate::store(
   case 3500000: baud = B3500000; break;
 # endif
 # ifdef B4000000
   case 4000000: baud = B4000000; break;
 # endif
   default:
-    baud = B0;
     ec = boost::asio::error::invalid_argument;
     return ec;
   }
 # if defined(_BSD_SOURCE)
   ::cfsetspeed(&storage, baud);
 # else
@@ -126,13 +125,13 @@ boost::system::error_code serial_port_base::baud_rate::store(
   return ec;
 }
 
 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);
   switch (baud)
   {
   // First do those specified by POSIX.
@@ -212,20 +211,20 @@ serial_port_base::flow_control::flow_control(
     serial_port_base::flow_control::type t)
   : value_(t)
 {
   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;
   storage.fDtrControl = DTR_CONTROL_ENABLE;
   storage.fDsrSensitivity = FALSE;
   storage.fOutX = FALSE;
@@ -286,13 +285,13 @@ boost::system::error_code serial_port_base::flow_control::store(
   return ec;
 }
 
 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;
   }
   else if (storage.fOutxCtsFlow && storage.fRtsControl == RTS_CONTROL_HANDSHAKE)
   {
@@ -330,20 +329,20 @@ boost::system::error_code serial_port_base::flow_control::load(
 serial_port_base::parity::parity(serial_port_base::parity::type t)
   : value_(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:
     storage.fParity = FALSE;
     storage.Parity = NOPARITY;
     break;
@@ -384,13 +383,13 @@ boost::system::error_code serial_port_base::parity::store(
   return ec;
 }
 
 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;
   }
   else if (storage.Parity == ODDPARITY)
   {
@@ -425,20 +424,20 @@ serial_port_base::stop_bits::stop_bits(
     serial_port_base::stop_bits::type t)
   : value_(t)
 {
   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:
     storage.StopBits = ONESTOPBIT;
     break;
   case onepointfive:
@@ -468,13 +467,13 @@ boost::system::error_code serial_port_base::stop_bits::store(
   return ec;
 }
 
 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;
   }
   else if (storage.StopBits == ONE5STOPBITS)
   {
@@ -498,20 +497,20 @@ boost::system::error_code serial_port_base::stop_bits::load(
 serial_port_base::character_size::character_size(unsigned int t)
   : value_(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;
   switch (value_)
   {
   case 5: storage.c_cflag |= CS5; break;
@@ -525,13 +524,13 @@ boost::system::error_code serial_port_base::character_size::store(
   return ec;
 }
 
 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; }
   else if ((storage.c_cflag & CSIZE) == CS6) { value_ = 6; }
   else if ((storage.c_cflag & CSIZE) == CS7) { value_ = 7; }
   else if ((storage.c_cflag & CSIZE) == CS8) { value_ = 8; }
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
@@ -1,11 +1,11 @@
 //
 // 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)
 //
 
 #ifndef BOOST_ASIO_IMPL_WRITE_HPP
@@ -20,12 +20,13 @@
 #include <boost/asio/detail/array_fwd.hpp>
 #include <boost/asio/detail/base_from_completion_cond.hpp>
 #include <boost/asio/detail/bind_handler.hpp>
 #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>
 
 #include <boost/asio/detail/push_options.hpp>
 
@@ -78,13 +79,13 @@ inline std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
   boost::system::error_code ec;
   std::size_t bytes_transferred = write(s, buffers, completion_condition, ec);
   boost::asio::detail::throw_error(ec, "write");
   return bytes_transferred;
 }
 
-#if !defined(BOOST_NO_IOSTREAM)
+#if !defined(BOOST_ASIO_NO_IOSTREAM)
 
 template <typename SyncWriteStream, typename Allocator,
     typename CompletionCondition>
 std::size_t write(SyncWriteStream& s,
     boost::asio::basic_streambuf<Allocator>& b,
     CompletionCondition completion_condition, boost::system::error_code& ec)
@@ -121,13 +122,13 @@ inline std::size_t write(SyncWriteStream& s,
   boost::system::error_code ec;
   std::size_t bytes_transferred = write(s, b, completion_condition, ec);
   boost::asio::detail::throw_error(ec, "write");
   return bytes_transferred;
 }
 
-#endif // !defined(BOOST_NO_IOSTREAM)
+#endif // !defined(BOOST_ASIO_NO_IOSTREAM)
 
 namespace detail
 {
   template <typename AsyncWriteStream, typename ConstBufferSequence,
       typename CompletionCondition, typename WriteHandler>
   class write_op
@@ -137,41 +138,44 @@ namespace detail
     write_op(AsyncWriteStream& stream, const ConstBufferSequence& buffers,
         CompletionCondition completion_condition, WriteHandler& handler)
       : detail::base_from_completion_cond<
           CompletionCondition>(completion_condition),
         stream_(stream),
         buffers_(buffers),
+        start_(0),
         total_transferred_(0),
         handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(handler))
     {
     }
 
 #if defined(BOOST_ASIO_HAS_MOVE)
     write_op(const write_op& other)
       : detail::base_from_completion_cond<CompletionCondition>(other),
         stream_(other.stream_),
         buffers_(other.buffers_),
+        start_(other.start_),
         total_transferred_(other.total_transferred_),
         handler_(other.handler_)
     {
     }
 
     write_op(write_op&& other)
       : 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_))
     {
     }
 #endif // defined(BOOST_ASIO_HAS_MOVE)
 
     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_));
         for (;;)
         {
           stream_.async_write_some(buffers_,
@@ -190,12 +194,13 @@ namespace detail
     }
 
   //private:
     AsyncWriteStream& stream_;
     boost::asio::detail::consuming_buffers<
       const_buffer, ConstBufferSequence> buffers_;
+    int start_;
     std::size_t total_transferred_;
     WriteHandler handler_;
   };
 
   template <typename AsyncWriteStream,
       typename CompletionCondition, typename WriteHandler>
@@ -209,42 +214,45 @@ namespace detail
         CompletionCondition completion_condition,
         WriteHandler& handler)
       : detail::base_from_completion_cond<
           CompletionCondition>(completion_condition),
         stream_(stream),
         buffer_(buffers),
+        start_(0),
         total_transferred_(0),
         handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(handler))
     {
     }
 
 #if defined(BOOST_ASIO_HAS_MOVE)
     write_op(const write_op& other)
       : detail::base_from_completion_cond<CompletionCondition>(other),
         stream_(other.stream_),
         buffer_(other.buffer_),
+        start_(other.start_),
         total_transferred_(other.total_transferred_),
         handler_(other.handler_)
     {
     }
 
     write_op(write_op&& other)
       : 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_))
     {
     }
 #endif // defined(BOOST_ASIO_HAS_MOVE)
 
     void operator()(const boost::system::error_code& ec,
         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_);
         for (;;)
         {
           stream_.async_write_some(
@@ -262,12 +270,13 @@ namespace detail
       }
     }
 
   //private:
     AsyncWriteStream& stream_;
     boost::asio::mutable_buffer buffer_;
+    int start_;
     std::size_t total_transferred_;
     WriteHandler handler_;
   };
 
   template <typename AsyncWriteStream,
       typename CompletionCondition, typename WriteHandler>
@@ -281,42 +290,45 @@ namespace detail
         CompletionCondition completion_condition,
         WriteHandler& handler)
       : detail::base_from_completion_cond<
           CompletionCondition>(completion_condition),
         stream_(stream),
         buffer_(buffers),
+        start_(0),
         total_transferred_(0),
         handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(handler))
     {
     }
 
 #if defined(BOOST_ASIO_HAS_MOVE)
     write_op(const write_op& other)
       : detail::base_from_completion_cond<CompletionCondition>(other),
         stream_(other.stream_),
         buffer_(other.buffer_),
+        start_(other.start_),
         total_transferred_(other.total_transferred_),
         handler_(other.handler_)
     {
     }
 
     write_op(write_op&& other)
       : 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_))
     {
     }
 #endif // defined(BOOST_ASIO_HAS_MOVE)
 
     void operator()(const boost::system::error_code& ec,
         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_);
         for (;;)
         {
           stream_.async_write_some(
@@ -334,12 +346,13 @@ namespace detail
       }
     }
 
   //private:
     AsyncWriteStream& stream_;
     boost::asio::const_buffer buffer_;
+    int start_;
     std::size_t total_transferred_;
     WriteHandler handler_;
   };
 
   template <typename AsyncWriteStream, typename Elem,
       typename CompletionCondition, typename WriteHandler>
@@ -351,31 +364,34 @@ namespace detail
     write_op(AsyncWriteStream& stream, const boost::array<Elem, 2>& buffers,
         CompletionCondition completion_condition, WriteHandler& handler)
       : detail::base_from_completion_cond<
           CompletionCondition>(completion_condition),
         stream_(stream),
         buffers_(buffers),
+        start_(0),
         total_transferred_(0),
         handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(handler))
     {
     }
 
 #if defined(BOOST_ASIO_HAS_MOVE)
     write_op(const write_op& other)
       : detail::base_from_completion_cond<CompletionCondition>(other),
         stream_(other.stream_),
         buffers_(other.buffers_),
+        start_(other.start_),
         total_transferred_(other.total_transferred_),
         handler_(other.handler_)
     {
     }
 
     write_op(write_op&& other)
       : 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_))
     {
     }
 #endif // defined(BOOST_ASIO_HAS_MOVE)
 
@@ -386,13 +402,13 @@ namespace detail
           boost::array<boost::asio::const_buffer, 2> >::type bufs = {{
         boost::asio::const_buffer(buffers_[0]),
         boost::asio::const_buffer(buffers_[1]) }};
       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_);
         for (;;)
         {
           bufs[0] = boost::asio::buffer(bufs[0] + total_transferred_, n);
@@ -413,12 +429,13 @@ namespace detail
       }
     }
 
   //private:
     AsyncWriteStream& stream_;
     boost::array<Elem, 2> buffers_;
+    int start_;
     std::size_t total_transferred_;
     WriteHandler handler_;
   };
 
 #if defined(BOOST_ASIO_HAS_STD_ARRAY)
 
@@ -432,31 +449,34 @@ namespace detail
     write_op(AsyncWriteStream& stream, const std::array<Elem, 2>& buffers,
         CompletionCondition completion_condition, WriteHandler& handler)
       : detail::base_from_completion_cond<
           CompletionCondition>(completion_condition),
         stream_(stream),
         buffers_(buffers),
+        start_(0),
         total_transferred_(0),
         handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(handler))
     {
     }
 
 #if defined(BOOST_ASIO_HAS_MOVE)
     write_op(const write_op& other)
       : detail::base_from_completion_cond<CompletionCondition>(other),
         stream_(other.stream_),
         buffers_(other.buffers_),
+        start_(other.start_),
         total_transferred_(other.total_transferred_),
         handler_(other.handler_)
     {
     }
 
     write_op(write_op&& other)
       : 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_))
     {
     }
 #endif // defined(BOOST_ASIO_HAS_MOVE)
 
@@ -467,13 +487,13 @@ namespace detail
           std::array<boost::asio::const_buffer, 2> >::type bufs = {{
         boost::asio::const_buffer(buffers_[0]),
         boost::asio::const_buffer(buffers_[1]) }};
       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_);
         for (;;)
         {
           bufs[0] = boost::asio::buffer(bufs[0] + total_transferred_, n);
@@ -494,12 +514,13 @@ namespace detail
       }
     }
 
   //private:
     AsyncWriteStream& stream_;
     std::array<Elem, 2> buffers_;
+    int start_;
     std::size_t total_transferred_;
     WriteHandler handler_;
   };
 
 #endif // defined(BOOST_ASIO_HAS_STD_ARRAY)
 
@@ -520,12 +541,23 @@ namespace detail
         CompletionCondition, WriteHandler>* this_handler)
   {
     boost_asio_handler_alloc_helpers::deallocate(
         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>
   inline void asio_handler_invoke(Function& function,
       write_op<AsyncWriteStream, ConstBufferSequence,
         CompletionCondition, WriteHandler>* this_handler)
@@ -541,56 +573,64 @@ namespace detail
       write_op<AsyncWriteStream, ConstBufferSequence,
         CompletionCondition, WriteHandler>* this_handler)
   {
     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)
 {
   // 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, 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
 {
   template <typename Allocator, typename WriteHandler>
   class write_streambuf_handler
   {
@@ -641,12 +681,20 @@ namespace detail
       write_streambuf_handler<Allocator, WriteHandler>* this_handler)
   {
     boost_asio_handler_alloc_helpers::deallocate(
         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)
   {
     boost_asio_handler_invoke_helpers::invoke(
         function, this_handler->handler_);
@@ -656,53 +704,63 @@ namespace detail
   inline void asio_handler_invoke(const Function& function,
       write_streambuf_handler<Allocator, WriteHandler>* this_handler)
   {
     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)
 {
   // 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(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)
 {
   // 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(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
 
 #include <boost/asio/detail/pop_options.hpp>
 
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
@@ -1,11 +1,11 @@
 //
 // 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)
 //
 
 #ifndef BOOST_ASIO_IMPL_WRITE_AT_HPP
@@ -20,25 +20,26 @@
 #include <boost/asio/detail/array_fwd.hpp>
 #include <boost/asio/detail/base_from_completion_cond.hpp>
 #include <boost/asio/detail/bind_handler.hpp>
 #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>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 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();
   boost::asio::detail::consuming_buffers<
     const_buffer, ConstBufferSequence> tmp(buffers);
   std::size_t total_transferred = 0;
@@ -55,136 +56,139 @@ std::size_t write_at(SyncRandomAccessWriteDevice& d,
   }
   return total_transferred;
 }
 
 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(
       d, offset, buffers, transfer_all(), ec);
   boost::asio::detail::throw_error(ec, "write_at");
   return bytes_transferred;
 }
 
 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);
 }
 
 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;
   std::size_t bytes_transferred = write_at(
       d, offset, buffers, completion_condition, ec);
   boost::asio::detail::throw_error(ec, "write_at");
   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(
       d, offset, b.data(), completion_condition, ec);
   b.consume(bytes_transferred);
   return bytes_transferred;
 }
 
 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);
   boost::asio::detail::throw_error(ec, "write_at");
   return bytes_transferred;
 }
 
 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);
 }
 
 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;
   std::size_t bytes_transferred = write_at(
       d, offset, b, completion_condition, ec);
   boost::asio::detail::throw_error(ec, "write_at");
   return bytes_transferred;
 }
 
-#endif // !defined(BOOST_NO_IOSTREAM)
+#endif // !defined(BOOST_ASIO_NO_IOSTREAM)
 
 namespace detail
 {
   template <typename AsyncRandomAccessWriteDevice, typename ConstBufferSequence,
       typename CompletionCondition, typename WriteHandler>
   class write_at_op
     : detail::base_from_completion_cond<CompletionCondition>
   {
   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))
     {
     }
 
 #if defined(BOOST_ASIO_HAS_MOVE)
     write_at_op(const write_at_op& other)
       : detail::base_from_completion_cond<CompletionCondition>(other),
         device_(other.device_),
         offset_(other.offset_),
         buffers_(other.buffers_),
+        start_(other.start_),
         total_transferred_(other.total_transferred_),
         handler_(other.handler_)
     {
     }
 
     write_at_op(write_at_op&& other)
       : detail::base_from_completion_cond<CompletionCondition>(other),
         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_))
     {
     }
 #endif // defined(BOOST_ASIO_HAS_MOVE)
 
     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_));
         for (;;)
         {
           device_.async_write_some_at(
@@ -202,67 +206,71 @@ namespace detail
         handler_(ec, static_cast<const std::size_t&>(total_transferred_));
       }
     }
 
   //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_;
   };
 
   template <typename AsyncRandomAccessWriteDevice,
       typename CompletionCondition, typename WriteHandler>
   class write_at_op<AsyncRandomAccessWriteDevice,
       boost::asio::mutable_buffers_1, CompletionCondition, WriteHandler>
     : detail::base_from_completion_cond<CompletionCondition>
   {
   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<
           CompletionCondition>(completion_condition),
         device_(device),
         offset_(offset),
         buffer_(buffers),
+        start_(0),
         total_transferred_(0),
         handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(handler))
     {
     }
 
 #if defined(BOOST_ASIO_HAS_MOVE)
     write_at_op(const write_at_op& other)
       : detail::base_from_completion_cond<CompletionCondition>(other),
         device_(other.device_),
         offset_(other.offset_),
         buffer_(other.buffer_),
+        start_(other.start_),
         total_transferred_(other.total_transferred_),
         handler_(other.handler_)
     {
     }
 
     write_at_op(write_at_op&& other)
       : detail::base_from_completion_cond<CompletionCondition>(other),
         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_))
     {
     }
 #endif // defined(BOOST_ASIO_HAS_MOVE)
 
     void operator()(const boost::system::error_code& ec,
         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_);
         for (;;)
         {
           device_.async_write_some_at(offset_ + total_transferred_,
@@ -279,66 +287,70 @@ namespace detail
         handler_(ec, static_cast<const std::size_t&>(total_transferred_));
       }
     }
 
   //private:
     AsyncRandomAccessWriteDevice& device_;
-    boost::uint64_t offset_;
+    uint64_t offset_;
     boost::asio::mutable_buffer buffer_;
+    int start_;
     std::size_t total_transferred_;
     WriteHandler handler_;
   };
 
   template <typename AsyncRandomAccessWriteDevice,
       typename CompletionCondition, typename WriteHandler>
   class write_at_op<AsyncRandomAccessWriteDevice, boost::asio::const_buffers_1,
       CompletionCondition, WriteHandler>
     : detail::base_from_completion_cond<CompletionCondition>
   {
   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<
           CompletionCondition>(completion_condition),
         device_(device),
         offset_(offset),
         buffer_(buffers),
+        start_(0),
         total_transferred_(0),
         handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(handler))
     {
     }
 
 #if defined(BOOST_ASIO_HAS_MOVE)
     write_at_op(const write_at_op& other)
       : detail::base_from_completion_cond<CompletionCondition>(other),
         device_(other.device_),
         offset_(other.offset_),
         buffer_(other.buffer_),
+        start_(other.start_),
         total_transferred_(other.total_transferred_),
         handler_(other.handler_)
     {
     }
 
     write_at_op(write_at_op&& other)
       : detail::base_from_completion_cond<CompletionCondition>(other),
         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_))
     {
     }
 #endif // defined(BOOST_ASIO_HAS_MOVE)
 
     void operator()(const boost::system::error_code& ec,
         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_);
         for (;;)
         {
           device_.async_write_some_at(offset_ + total_transferred_,
@@ -355,54 +367,58 @@ namespace detail
         handler_(ec, static_cast<const std::size_t&>(total_transferred_));
       }
     }
 
   //private:
     AsyncRandomAccessWriteDevice& device_;
-    boost::uint64_t offset_;
+    uint64_t offset_;
     boost::asio::const_buffer buffer_;
+    int start_;
     std::size_t total_transferred_;
     WriteHandler handler_;
   };
 
   template <typename AsyncRandomAccessWriteDevice, typename Elem,
       typename CompletionCondition, typename WriteHandler>
   class write_at_op<AsyncRandomAccessWriteDevice, boost::array<Elem, 2>,
       CompletionCondition, WriteHandler>
     : detail::base_from_completion_cond<CompletionCondition>
   {
   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))
     {
     }
 
 #if defined(BOOST_ASIO_HAS_MOVE)
     write_at_op(const write_at_op& other)
       : detail::base_from_completion_cond<CompletionCondition>(other),
         device_(other.device_),
         offset_(other.offset_),
         buffers_(other.buffers_),
+        start_(other.start_),
         total_transferred_(other.total_transferred_),
         handler_(other.handler_)
     {
     }
 
     write_at_op(write_at_op&& other)
       : detail::base_from_completion_cond<CompletionCondition>(other),
         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_))
     {
     }
 #endif // defined(BOOST_ASIO_HAS_MOVE)
 
@@ -413,13 +429,13 @@ namespace detail
           boost::array<boost::asio::const_buffer, 2> >::type bufs = {{
         boost::asio::const_buffer(buffers_[0]),
         boost::asio::const_buffer(buffers_[1]) }};
       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_);
         for (;;)
         {
           bufs[0] = boost::asio::buffer(bufs[0] + total_transferred_, n);
@@ -440,14 +456,15 @@ namespace detail
         handler_(ec, static_cast<const std::size_t&>(total_transferred_));
       }
     }
 
   //private:
     AsyncRandomAccessWriteDevice& device_;
-    boost::uint64_t offset_;
+    uint64_t offset_;
     boost::array<Elem, 2> buffers_;
+    int start_;
     std::size_t total_transferred_;
     WriteHandler handler_;
   };
 
 #if defined(BOOST_ASIO_HAS_STD_ARRAY)
 
@@ -456,40 +473,43 @@ namespace detail
   class write_at_op<AsyncRandomAccessWriteDevice, std::array<Elem, 2>,
       CompletionCondition, WriteHandler>
     : detail::base_from_completion_cond<CompletionCondition>
   {
   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))
     {
     }
 
 #if defined(BOOST_ASIO_HAS_MOVE)
     write_at_op(const write_at_op& other)
       : detail::base_from_completion_cond<CompletionCondition>(other),
         device_(other.device_),
         offset_(other.offset_),
         buffers_(other.buffers_),
+        start_(other.start_),
         total_transferred_(other.total_transferred_),
         handler_(other.handler_)
     {
     }
 
     write_at_op(write_at_op&& other)
       : detail::base_from_completion_cond<CompletionCondition>(other),
         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_))
     {
     }
 #endif // defined(BOOST_ASIO_HAS_MOVE)
 
@@ -500,13 +520,13 @@ namespace detail
           std::array<boost::asio::const_buffer, 2> >::type bufs = {{
         boost::asio::const_buffer(buffers_[0]),
         boost::asio::const_buffer(buffers_[1]) }};
       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_);
         for (;;)
         {
           bufs[0] = boost::asio::buffer(bufs[0] + total_transferred_, n);
@@ -527,14 +547,15 @@ namespace detail
         handler_(ec, static_cast<const std::size_t&>(total_transferred_));
       }
     }
 
   //private:
     AsyncRandomAccessWriteDevice& device_;
-    boost::uint64_t offset_;
+    uint64_t offset_;
     std::array<Elem, 2> buffers_;
+    int start_;
     std::size_t total_transferred_;
     WriteHandler handler_;
   };
 
 #endif // defined(BOOST_ASIO_HAS_STD_ARRAY)
 
@@ -555,12 +576,23 @@ namespace detail
         CompletionCondition, WriteHandler>* this_handler)
   {
     boost_asio_handler_alloc_helpers::deallocate(
         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>
   inline void asio_handler_invoke(Function& function,
       write_at_op<AsyncRandomAccessWriteDevice, ConstBufferSequence,
         CompletionCondition, WriteHandler>* this_handler)
@@ -582,55 +614,73 @@ namespace detail
 
   template <typename AsyncRandomAccessWriteDevice, typename ConstBufferSequence,
       typename CompletionCondition, typename WriteHandler>
   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,
       ConstBufferSequence, CompletionCondition, WriteHandler>(
         d, offset, buffers, completion_condition, handler);
   }
 } // 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)
 {
   // 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, 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
 {
   template <typename Allocator, typename WriteHandler>
   class write_at_streambuf_op
   {
@@ -682,12 +732,20 @@ namespace detail
       write_at_streambuf_op<Allocator, WriteHandler>* this_handler)
   {
     boost_asio_handler_alloc_helpers::deallocate(
         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)
   {
     boost_asio_handler_invoke_helpers::invoke(
         function, this_handler->handler_);
@@ -709,42 +767,60 @@ namespace detail
     return write_at_streambuf_op<Allocator, WriteHandler>(b, handler);
   }
 } // 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)
 {
   // 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(), 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
 
 #include <boost/asio/detail/pop_options.hpp>
 
diff --git a/3rdParty/Boost/src/boost/asio/io_service.hpp b/3rdParty/Boost/src/boost/asio/io_service.hpp
index 43b94e4..16b0bbf 100644
--- a/3rdParty/Boost/src/boost/asio/io_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/io_service.hpp
@@ -1,11 +1,11 @@
 //
 // 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)
 //
 
 #ifndef BOOST_ASIO_IO_SERVICE_HPP
@@ -16,24 +16,18 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 #include <cstddef>
 #include <stdexcept>
 #include <typeinfo>
+#include <boost/asio/async_result.hpp>
 #include <boost/asio/detail/noncopyable.hpp>
-#include <boost/asio/detail/service_registry_fwd.hpp>
 #include <boost/asio/detail/wrapped_handler.hpp>
 #include <boost/system/error_code.hpp>
 
-#if defined(BOOST_ASIO_HAS_IOCP)
-# include <boost/asio/detail/win_iocp_io_service_fwd.hpp>
-#else
-# include <boost/asio/detail/task_io_service_fwd.hpp>
-#endif
-
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
 # include <boost/asio/detail/winsock_init.hpp>
 #elif defined(__sun) || defined(__QNX__) || defined(__hpux) || defined(_AIX) \
   || defined(__osf__)
 # include <boost/asio/detail/signal_init.hpp>
 #endif
 
@@ -44,17 +38,21 @@ namespace asio {
 
 class io_service;
 template <typename Service> Service& use_service(io_service& ios);
 template <typename Service> void add_service(io_service& ios, Service* svc);
 template <typename Service> bool has_service(io_service& ios);
 
+namespace detail {
 #if defined(BOOST_ASIO_HAS_IOCP)
-namespace detail { typedef win_iocp_io_service io_service_impl; }
+  typedef class win_iocp_io_service io_service_impl;
+  class win_iocp_overlapped_ptr;
 #else
-namespace detail { typedef task_io_service io_service_impl; }
+  typedef class task_io_service io_service_impl;
 #endif
+  class service_registry;
+} // namespace detail
 
 /// Provides core I/O functionality.
 /**
  * The io_service class provides the core I/O functionality for users of the
  * asynchronous I/O objects, including:
  *
@@ -438,13 +436,14 @@ public:
    *
    * @li the handler's copy constructor
    *
    * throws an exception.
    */
   template <typename CompletionHandler>
-  void dispatch(BOOST_ASIO_MOVE_ARG(CompletionHandler) handler);
+  BOOST_ASIO_INITFN_RESULT_TYPE(CompletionHandler, void ())
+  dispatch(BOOST_ASIO_MOVE_ARG(CompletionHandler) handler);
 
   /// Request the io_service to invoke the given handler and return immediately.
   /**
    * This function is used to ask the io_service to execute the given handler,
    * but without allowing the io_service to call the handler from inside this
    * function.
@@ -463,13 +462,14 @@ public:
    *
    * @li the handler's copy constructor
    *
    * throws an exception.
    */
   template <typename CompletionHandler>
-  void post(BOOST_ASIO_MOVE_ARG(CompletionHandler) handler);
+  BOOST_ASIO_INITFN_RESULT_TYPE(CompletionHandler, void ())
+  post(BOOST_ASIO_MOVE_ARG(CompletionHandler) handler);
 
   /// Create a new handler that automatically dispatches the wrapped handler
   /// on the io_service.
   /**
    * This function is used to create a new handler function object that, when
    * invoked, will automatically pass the wrapped handler to the io_service
@@ -597,13 +597,13 @@ public:
    * @return A boolean indicating whether the io_service contains the service.
    */
   template <typename Service>
   friend bool has_service(io_service& ios);
 
 private:
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
   detail::winsock_init<> init_;
 #elif defined(__sun) || defined(__QNX__) || defined(__hpux) || defined(_AIX) \
   || defined(__osf__)
   detail::signal_init<> init_;
 #endif
 
diff --git a/3rdParty/Boost/src/boost/asio/ip/address.hpp b/3rdParty/Boost/src/boost/asio/ip/address.hpp
index 9e62c04..e412313 100644
--- a/3rdParty/Boost/src/boost/asio/ip/address.hpp
+++ b/3rdParty/Boost/src/boost/asio/ip/address.hpp
@@ -1,11 +1,11 @@
 //
 // ip/address.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)
 //
 
 #ifndef BOOST_ASIO_IP_ADDRESS_HPP
@@ -18,15 +18,15 @@
 #include <boost/asio/detail/config.hpp>
 #include <string>
 #include <boost/system/error_code.hpp>
 #include <boost/asio/ip/address_v4.hpp>
 #include <boost/asio/ip/address_v6.hpp>
 
-#if !defined(BOOST_NO_IOSTREAM)
+#if !defined(BOOST_ASIO_NO_IOSTREAM)
 # include <iosfwd>
-#endif // !defined(BOOST_NO_IOSTREAM)
+#endif // !defined(BOOST_ASIO_NO_IOSTREAM)
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace ip {
@@ -165,13 +165,13 @@ private:
   boost::asio::ip::address_v4 ipv4_address_;
 
   // The underlying IPv6 address.
   boost::asio::ip::address_v6 ipv6_address_;
 };
 
-#if !defined(BOOST_NO_IOSTREAM)
+#if !defined(BOOST_ASIO_NO_IOSTREAM)
 
 /// Output an address as a string.
 /**
  * Used to output a human-readable string for a specified address.
  *
  * @param os The output stream to which the string will be written.
@@ -183,13 +183,13 @@ private:
  * @relates boost::asio::ip::address
  */
 template <typename Elem, typename Traits>
 std::basic_ostream<Elem, Traits>& operator<<(
     std::basic_ostream<Elem, Traits>& os, const address& addr);
 
-#endif // !defined(BOOST_NO_IOSTREAM)
+#endif // !defined(BOOST_ASIO_NO_IOSTREAM)
 
 } // namespace ip
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
diff --git a/3rdParty/Boost/src/boost/asio/ip/address_v4.hpp b/3rdParty/Boost/src/boost/asio/ip/address_v4.hpp
index 8d11921..3b2fe0f 100644
--- a/3rdParty/Boost/src/boost/asio/ip/address_v4.hpp
+++ b/3rdParty/Boost/src/boost/asio/ip/address_v4.hpp
@@ -1,11 +1,11 @@
 //
 // ip/address_v4.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)
 //
 
 #ifndef BOOST_ASIO_IP_ADDRESS_V4_HPP
@@ -19,15 +19,15 @@
 #include <string>
 #include <boost/asio/detail/array.hpp>
 #include <boost/asio/detail/socket_types.hpp>
 #include <boost/asio/detail/winsock_init.hpp>
 #include <boost/system/error_code.hpp>
 
-#if !defined(BOOST_NO_IOSTREAM)
+#if !defined(BOOST_ASIO_NO_IOSTREAM)
 # include <iosfwd>
-#endif // !defined(BOOST_NO_IOSTREAM)
+#endif // !defined(BOOST_ASIO_NO_IOSTREAM)
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace ip {
@@ -206,13 +206,13 @@ public:
 
 private:
   // The underlying IPv4 address.
   boost::asio::detail::in4_addr_type addr_;
 };
 
-#if !defined(BOOST_NO_IOSTREAM)
+#if !defined(BOOST_ASIO_NO_IOSTREAM)
 
 /// Output an address as a string.
 /**
  * Used to output a human-readable string for a specified address.
  *
  * @param os The output stream to which the string will be written.
@@ -224,13 +224,13 @@ private:
  * @relates boost::asio::ip::address_v4
  */
 template <typename Elem, typename Traits>
 std::basic_ostream<Elem, Traits>& operator<<(
     std::basic_ostream<Elem, Traits>& os, const address_v4& addr);
 
-#endif // !defined(BOOST_NO_IOSTREAM)
+#endif // !defined(BOOST_ASIO_NO_IOSTREAM)
 
 } // namespace ip
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
diff --git a/3rdParty/Boost/src/boost/asio/ip/address_v6.hpp b/3rdParty/Boost/src/boost/asio/ip/address_v6.hpp
index e35a176..0ec2818 100644
--- a/3rdParty/Boost/src/boost/asio/ip/address_v6.hpp
+++ b/3rdParty/Boost/src/boost/asio/ip/address_v6.hpp
@@ -1,11 +1,11 @@
 //
 // ip/address_v6.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)
 //
 
 #ifndef BOOST_ASIO_IP_ADDRESS_V6_HPP
@@ -20,15 +20,15 @@
 #include <boost/asio/detail/array.hpp>
 #include <boost/asio/detail/socket_types.hpp>
 #include <boost/asio/detail/winsock_init.hpp>
 #include <boost/system/error_code.hpp>
 #include <boost/asio/ip/address_v4.hpp>
 
-#if !defined(BOOST_NO_IOSTREAM)
+#if !defined(BOOST_ASIO_NO_IOSTREAM)
 # include <iosfwd>
-#endif // !defined(BOOST_NO_IOSTREAM)
+#endif // !defined(BOOST_ASIO_NO_IOSTREAM)
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace ip {
@@ -211,13 +211,13 @@ private:
   boost::asio::detail::in6_addr_type addr_;
 
   // The scope ID associated with the address.
   unsigned long scope_id_;
 };
 
-#if !defined(BOOST_NO_IOSTREAM)
+#if !defined(BOOST_ASIO_NO_IOSTREAM)
 
 /// Output an address as a string.
 /**
  * Used to output a human-readable string for a specified address.
  *
  * @param os The output stream to which the string will be written.
@@ -229,13 +229,13 @@ private:
  * @relates boost::asio::ip::address_v6
  */
 template <typename Elem, typename Traits>
 std::basic_ostream<Elem, Traits>& operator<<(
     std::basic_ostream<Elem, Traits>& os, const address_v6& addr);
 
-#endif // !defined(BOOST_NO_IOSTREAM)
+#endif // !defined(BOOST_ASIO_NO_IOSTREAM)
 
 } // namespace ip
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
diff --git a/3rdParty/Boost/src/boost/asio/ip/basic_endpoint.hpp b/3rdParty/Boost/src/boost/asio/ip/basic_endpoint.hpp
index 9eefe4c..d4a80f3 100644
--- a/3rdParty/Boost/src/boost/asio/ip/basic_endpoint.hpp
+++ b/3rdParty/Boost/src/boost/asio/ip/basic_endpoint.hpp
@@ -1,11 +1,11 @@
 //
 // ip/basic_endpoint.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)
 //
 
 #ifndef BOOST_ASIO_IP_BASIC_ENDPOINT_HPP
@@ -16,15 +16,15 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 #include <boost/asio/ip/address.hpp>
 #include <boost/asio/ip/detail/endpoint.hpp>
 
-#if !defined(BOOST_NO_IOSTREAM)
+#if !defined(BOOST_ASIO_NO_IOSTREAM)
 # include <iosfwd>
-#endif // !defined(BOOST_NO_IOSTREAM)
+#endif // !defined(BOOST_ASIO_NO_IOSTREAM)
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace ip {
@@ -230,13 +230,13 @@ public:
 
 private:
   // The underlying IP endpoint.
   boost::asio::ip::detail::endpoint impl_;
 };
 
-#if !defined(BOOST_NO_IOSTREAM)
+#if !defined(BOOST_ASIO_NO_IOSTREAM)
 
 /// Output an endpoint as a string.
 /**
  * Used to output a human-readable string for a specified endpoint.
  *
  * @param os The output stream to which the string will be written.
@@ -249,13 +249,13 @@ private:
  */
 template <typename Elem, typename Traits, typename InternetProtocol>
 std::basic_ostream<Elem, Traits>& operator<<(
     std::basic_ostream<Elem, Traits>& os,
     const basic_endpoint<InternetProtocol>& endpoint);
 
-#endif // !defined(BOOST_NO_IOSTREAM)
+#endif // !defined(BOOST_ASIO_NO_IOSTREAM)
 
 } // namespace ip
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
diff --git a/3rdParty/Boost/src/boost/asio/ip/basic_resolver.hpp b/3rdParty/Boost/src/boost/asio/ip/basic_resolver.hpp
index 6265890..a4593af 100644
--- a/3rdParty/Boost/src/boost/asio/ip/basic_resolver.hpp
+++ b/3rdParty/Boost/src/boost/asio/ip/basic_resolver.hpp
@@ -1,11 +1,11 @@
 //
 // ip/basic_resolver.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)
 //
 
 #ifndef BOOST_ASIO_IP_BASIC_RESOLVER_HPP
@@ -150,13 +150,15 @@ public:
    * @note A default constructed iterator represents the end of the list.
    *
    * A successful resolve operation is guaranteed to pass at least one entry to
    * the handler.
    */
   template <typename ResolveHandler>
-  void async_resolve(const query& q,
+  BOOST_ASIO_INITFN_RESULT_TYPE(ResolveHandler,
+      void (boost::system::error_code, iterator))
+  async_resolve(const query& q,
       BOOST_ASIO_MOVE_ARG(ResolveHandler) handler)
   {
     // If you get an error on the following line it means that your handler does
     // not meet the documented type requirements for a ResolveHandler.
     BOOST_ASIO_RESOLVE_HANDLER_CHECK(
         ResolveHandler, handler, iterator) type_check;
@@ -241,13 +243,15 @@ public:
    * @note A default constructed iterator represents the end of the list.
    *
    * A successful resolve operation is guaranteed to pass at least one entry to
    * the handler.
    */
   template <typename ResolveHandler>
-  void async_resolve(const endpoint_type& e,
+  BOOST_ASIO_INITFN_RESULT_TYPE(ResolveHandler,
+      void (boost::system::error_code, iterator))
+  async_resolve(const endpoint_type& e,
       BOOST_ASIO_MOVE_ARG(ResolveHandler) handler)
   {
     // If you get an error on the following line it means that your handler does
     // not meet the documented type requirements for a ResolveHandler.
     BOOST_ASIO_RESOLVE_HANDLER_CHECK(
         ResolveHandler, handler, iterator) type_check;
diff --git a/3rdParty/Boost/src/boost/asio/ip/basic_resolver_entry.hpp b/3rdParty/Boost/src/boost/asio/ip/basic_resolver_entry.hpp
index d170ab0..6fef220 100644
--- a/3rdParty/Boost/src/boost/asio/ip/basic_resolver_entry.hpp
+++ b/3rdParty/Boost/src/boost/asio/ip/basic_resolver_entry.hpp
@@ -1,11 +1,11 @@
 //
 // ip/basic_resolver_entry.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)
 //
 
 #ifndef BOOST_ASIO_IP_BASIC_RESOLVER_ENTRY_HPP
diff --git a/3rdParty/Boost/src/boost/asio/ip/basic_resolver_iterator.hpp b/3rdParty/Boost/src/boost/asio/ip/basic_resolver_iterator.hpp
index 6e52a85..c32d702 100644
--- a/3rdParty/Boost/src/boost/asio/ip/basic_resolver_iterator.hpp
+++ b/3rdParty/Boost/src/boost/asio/ip/basic_resolver_iterator.hpp
@@ -1,11 +1,11 @@
 //
 // ip/basic_resolver_iterator.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)
 //
 
 #ifndef BOOST_ASIO_IP_BASIC_RESOLVER_ITERATOR_HPP
@@ -23,12 +23,16 @@
 #include <vector>
 #include <boost/asio/detail/shared_ptr.hpp>
 #include <boost/asio/detail/socket_ops.hpp>
 #include <boost/asio/detail/socket_types.hpp>
 #include <boost/asio/ip/basic_resolver_entry.hpp>
 
+#if defined(BOOST_ASIO_WINDOWS_RUNTIME)
+# include <boost/asio/detail/winrt_utils.hpp>
+#endif // defined(BOOST_ASIO_WINDOWS_RUNTIME)
+
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace ip {
 
@@ -83,14 +87,14 @@ public:
       actual_host_name = address_info->ai_canonname;
 
     iter.values_.reset(new values_type);
 
     while (address_info)
     {
-      if (address_info->ai_family == PF_INET
-          || address_info->ai_family == PF_INET6)
+      if (address_info->ai_family == BOOST_ASIO_OS_DEF(AF_INET)
+          || address_info->ai_family == BOOST_ASIO_OS_DEF(AF_INET6))
       {
         using namespace std; // For memcpy.
         typename InternetProtocol::endpoint endpoint;
         endpoint.resize(static_cast<std::size_t>(address_info->ai_addrlen));
         memcpy(endpoint.data(), address_info->ai_addr,
             address_info->ai_addrlen);
@@ -114,12 +118,73 @@ public:
     iter.values_->push_back(
         basic_resolver_entry<InternetProtocol>(
           endpoint, host_name, service_name));
     return iter;
   }
 
+  /// Create an iterator from a sequence of endpoints, host and service name.
+  template <typename EndpointIterator>
+  static basic_resolver_iterator create(
+      EndpointIterator begin, EndpointIterator end,
+      const std::string& host_name, const std::string& service_name)
+  {
+    basic_resolver_iterator iter;
+    if (begin != end)
+    {
+      iter.values_.reset(new values_type);
+      for (EndpointIterator ep_iter = begin; ep_iter != end; ++ep_iter)
+      {
+        iter.values_->push_back(
+            basic_resolver_entry<InternetProtocol>(
+              *ep_iter, host_name, service_name));
+      }
+    }
+    return iter;
+  }
+
+#if defined(BOOST_ASIO_WINDOWS_RUNTIME)
+  /// Create an iterator from a Windows Runtime list of EndpointPair objects.
+  static basic_resolver_iterator create(
+      Windows::Foundation::Collections::IVectorView<
+        Windows::Networking::EndpointPair^>^ endpoints,
+      const boost::asio::detail::addrinfo_type& hints,
+      const std::string& host_name, const std::string& service_name)
+  {
+    basic_resolver_iterator iter;
+    if (endpoints->Size)
+    {
+      iter.values_.reset(new values_type);
+      for (unsigned int i = 0; i < endpoints->Size; ++i)
+      {
+        auto pair = endpoints->GetAt(i);
+
+        if (hints.ai_family == BOOST_ASIO_OS_DEF(AF_INET)
+            && pair->RemoteHostName->Type
+              != Windows::Networking::HostNameType::Ipv4)
+          continue;
+
+        if (hints.ai_family == BOOST_ASIO_OS_DEF(AF_INET6)
+            && pair->RemoteHostName->Type
+              != Windows::Networking::HostNameType::Ipv6)
+          continue;
+
+        iter.values_->push_back(
+            basic_resolver_entry<InternetProtocol>(
+              typename InternetProtocol::endpoint(
+                ip::address::from_string(
+                  boost::asio::detail::winrt_utils::string(
+                    pair->RemoteHostName->CanonicalName)),
+                boost::asio::detail::winrt_utils::integer(
+                  pair->RemoteServiceName)),
+              host_name, service_name));
+      }
+    }
+    return iter;
+  }
+#endif // defined(BOOST_ASIO_WINDOWS_RUNTIME)
+
   /// Dereference an iterator.
   const basic_resolver_entry<InternetProtocol>& operator*() const
   {
     return dereference();
   }
 
diff --git a/3rdParty/Boost/src/boost/asio/ip/basic_resolver_query.hpp b/3rdParty/Boost/src/boost/asio/ip/basic_resolver_query.hpp
index 0f7a54d..f8dcd2f 100644
--- a/3rdParty/Boost/src/boost/asio/ip/basic_resolver_query.hpp
+++ b/3rdParty/Boost/src/boost/asio/ip/basic_resolver_query.hpp
@@ -1,11 +1,11 @@
 //
 // ip/basic_resolver_query.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)
 //
 
 #ifndef BOOST_ASIO_IP_BASIC_RESOLVER_QUERY_HPP
@@ -150,13 +150,13 @@ public:
     : hints_(),
       host_name_(host),
       service_name_(service)
   {
     typename InternetProtocol::endpoint endpoint;
     hints_.ai_flags = static_cast<int>(resolve_flags);
-    hints_.ai_family = PF_UNSPEC;
+    hints_.ai_family = BOOST_ASIO_OS_DEF(AF_UNSPEC);
     hints_.ai_socktype = endpoint.protocol().type();
     hints_.ai_protocol = endpoint.protocol().protocol();
     hints_.ai_addrlen = 0;
     hints_.ai_canonname = 0;
     hints_.ai_addr = 0;
     hints_.ai_next = 0;
diff --git a/3rdParty/Boost/src/boost/asio/ip/detail/endpoint.hpp b/3rdParty/Boost/src/boost/asio/ip/detail/endpoint.hpp
index 04335ef..f171d58 100644
--- a/3rdParty/Boost/src/boost/asio/ip/detail/endpoint.hpp
+++ b/3rdParty/Boost/src/boost/asio/ip/detail/endpoint.hpp
@@ -1,11 +1,11 @@
 //
 // ip/detail/endpoint.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)
 //
 
 #ifndef BOOST_ASIO_IP_DETAIL_ENDPOINT_HPP
@@ -106,19 +106,19 @@ public:
   BOOST_ASIO_DECL friend bool operator<(
       const endpoint& e1, const endpoint& e2);
 
   // Determine whether the endpoint is IPv4.
   bool is_v4() const
   {
-    return data_.base.sa_family == AF_INET;
+    return data_.base.sa_family == BOOST_ASIO_OS_DEF(AF_INET);
   }
 
-#if !defined(BOOST_NO_IOSTREAM)
+#if !defined(BOOST_ASIO_NO_IOSTREAM)
   // Convert to a string.
   BOOST_ASIO_DECL std::string to_string(boost::system::error_code& ec) const;
-#endif // !defined(BOOST_NO_IOSTREAM)
+#endif // !defined(BOOST_ASIO_NO_IOSTREAM)
 
 private:
   // The underlying IP socket address.
   union data_union
   {
     boost::asio::detail::socket_addr_type base;
diff --git a/3rdParty/Boost/src/boost/asio/ip/detail/impl/endpoint.ipp b/3rdParty/Boost/src/boost/asio/ip/detail/impl/endpoint.ipp
index 24bfce2..4ad5046 100644
--- a/3rdParty/Boost/src/boost/asio/ip/detail/impl/endpoint.ipp
+++ b/3rdParty/Boost/src/boost/asio/ip/detail/impl/endpoint.ipp
@@ -1,11 +1,11 @@
 //
 // ip/detail/impl/endpoint.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)
 //
 
 #ifndef BOOST_ASIO_IP_DETAIL_IMPL_ENDPOINT_IPP
@@ -14,15 +14,15 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 #include <cstring>
-#if !defined(BOOST_NO_IOSTREAM)
+#if !defined(BOOST_ASIO_NO_IOSTREAM)
 # include <sstream>
-#endif // !defined(BOOST_NO_IOSTREAM)
+#endif // !defined(BOOST_ASIO_NO_IOSTREAM)
 #include <boost/asio/detail/socket_ops.hpp>
 #include <boost/asio/detail/throw_error.hpp>
 #include <boost/asio/error.hpp>
 #include <boost/asio/ip/detail/endpoint.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
@@ -32,31 +32,31 @@ namespace asio {
 namespace ip {
 namespace detail {
 
 endpoint::endpoint()
   : data_()
 {
-  data_.v4.sin_family = AF_INET;
+  data_.v4.sin_family = BOOST_ASIO_OS_DEF(AF_INET);
   data_.v4.sin_port = 0;
-  data_.v4.sin_addr.s_addr = INADDR_ANY;
+  data_.v4.sin_addr.s_addr = BOOST_ASIO_OS_DEF(INADDR_ANY);
 }
 
 endpoint::endpoint(int family, unsigned short port_num)
   : data_()
 {
   using namespace std; // For memcpy.
-  if (family == PF_INET)
+  if (family == BOOST_ASIO_OS_DEF(AF_INET))
   {
-    data_.v4.sin_family = AF_INET;
+    data_.v4.sin_family = BOOST_ASIO_OS_DEF(AF_INET);
     data_.v4.sin_port =
       boost::asio::detail::socket_ops::host_to_network_short(port_num);
-    data_.v4.sin_addr.s_addr = INADDR_ANY;
+    data_.v4.sin_addr.s_addr = BOOST_ASIO_OS_DEF(INADDR_ANY);
   }
   else
   {
-    data_.v6.sin6_family = AF_INET6;
+    data_.v6.sin6_family = BOOST_ASIO_OS_DEF(AF_INET6);
     data_.v6.sin6_port =
       boost::asio::detail::socket_ops::host_to_network_short(port_num);
     data_.v6.sin6_flowinfo = 0;
     data_.v6.sin6_addr.s6_addr[0] = 0; data_.v6.sin6_addr.s6_addr[1] = 0;
     data_.v6.sin6_addr.s6_addr[2] = 0, data_.v6.sin6_addr.s6_addr[3] = 0;
     data_.v6.sin6_addr.s6_addr[4] = 0, data_.v6.sin6_addr.s6_addr[5] = 0;
@@ -73,29 +73,32 @@ endpoint::endpoint(const boost::asio::ip::address& addr,
     unsigned short port_num)
   : data_()
 {
   using namespace std; // For memcpy.
   if (addr.is_v4())
   {
-    data_.v4.sin_family = AF_INET;
+    data_.v4.sin_family = BOOST_ASIO_OS_DEF(AF_INET);
     data_.v4.sin_port =
       boost::asio::detail::socket_ops::host_to_network_short(port_num);
     data_.v4.sin_addr.s_addr =
       boost::asio::detail::socket_ops::host_to_network_long(
-          addr.to_v4().to_ulong());
+          static_cast<boost::asio::detail::u_long_type>(
+            addr.to_v4().to_ulong()));
   }
   else
   {
-    data_.v6.sin6_family = AF_INET6;
+    data_.v6.sin6_family = BOOST_ASIO_OS_DEF(AF_INET6);
     data_.v6.sin6_port =
       boost::asio::detail::socket_ops::host_to_network_short(port_num);
     data_.v6.sin6_flowinfo = 0;
     boost::asio::ip::address_v6 v6_addr = addr.to_v6();
     boost::asio::ip::address_v6::bytes_type bytes = v6_addr.to_bytes();
     memcpy(data_.v6.sin6_addr.s6_addr, bytes.data(), 16);
-    data_.v6.sin6_scope_id = v6_addr.scope_id();
+    data_.v6.sin6_scope_id =
+      static_cast<boost::asio::detail::u_long_type>(
+        v6_addr.scope_id());
   }
 }
 
 void endpoint::resize(std::size_t new_size)
 {
   if (new_size > sizeof(boost::asio::detail::sockaddr_storage_type))
@@ -171,13 +174,13 @@ bool operator<(const endpoint& e1, const endpoint& e2)
     return true;
   if (e1.address() != e2.address())
     return false;
   return e1.port() < e2.port();
 }
 
-#if !defined(BOOST_NO_IOSTREAM)
+#if !defined(BOOST_ASIO_NO_IOSTREAM)
 std::string endpoint::to_string(boost::system::error_code& ec) const
 {
   std::string a = address().to_string(ec);
   if (ec)
     return std::string();
 
@@ -188,13 +191,13 @@ std::string endpoint::to_string(boost::system::error_code& ec) const
   else
     tmp_os << '[' << a << ']';
   tmp_os << ':' << port();
 
   return tmp_os.str();
 }
-#endif // !defined(BOOST_NO_IOSTREAM)
+#endif // !defined(BOOST_ASIO_NO_IOSTREAM)
 
 } // namespace detail
 } // namespace ip
 } // namespace asio
 } // namespace boost
 
diff --git a/3rdParty/Boost/src/boost/asio/ip/detail/socket_option.hpp b/3rdParty/Boost/src/boost/asio/ip/detail/socket_option.hpp
index 041a9f8..3b053f1 100644
--- a/3rdParty/Boost/src/boost/asio/ip/detail/socket_option.hpp
+++ b/3rdParty/Boost/src/boost/asio/ip/detail/socket_option.hpp
@@ -1,11 +1,11 @@
 //
 // detail/socket_option.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)
 //
 
 #ifndef BOOST_ASIO_IP_DETAIL_SOCKET_OPTION_HPP
@@ -16,15 +16,15 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 #include <cstddef>
 #include <cstring>
 #include <stdexcept>
-#include <boost/throw_exception.hpp>
 #include <boost/asio/detail/socket_ops.hpp>
 #include <boost/asio/detail/socket_types.hpp>
+#include <boost/asio/detail/throw_exception.hpp>
 #include <boost/asio/ip/address.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
@@ -139,22 +139,22 @@ public:
   {
     if (protocol.family() == PF_INET6)
     {
       if (s != sizeof(ipv6_value_))
       {
         std::length_error ex("multicast_enable_loopback socket option resize");
-        boost::throw_exception(ex);
+        boost::asio::detail::throw_exception(ex);
       }
       ipv4_value_ = ipv6_value_ ? 1 : 0;
     }
     else
     {
       if (s != sizeof(ipv4_value_))
       {
         std::length_error ex("multicast_enable_loopback socket option resize");
-        boost::throw_exception(ex);
+        boost::asio::detail::throw_exception(ex);
       }
       ipv6_value_ = ipv4_value_ ? 1 : 0;
     }
   }
 
 private:
@@ -235,13 +235,13 @@ public:
   template <typename Protocol>
   void resize(const Protocol&, std::size_t s)
   {
     if (s != sizeof(value_))
     {
       std::length_error ex("unicast hops socket option resize");
-      boost::throw_exception(ex);
+      boost::asio::detail::throw_exception(ex);
     }
 #if defined(__hpux)
     if (value_ < 0)
       value_ = value_ & 0xFF;
 #endif
   }
@@ -252,13 +252,13 @@ private:
 
 // Helper template for implementing multicast hops options.
 template <int IPv4_Level, int IPv4_Name, int IPv6_Level, int IPv6_Name>
 class multicast_hops
 {
 public:
-#if defined(BOOST_WINDOWS) && defined(UNDER_CE)
+#if defined(BOOST_ASIO_WINDOWS) && defined(UNDER_CE)
   typedef int ipv4_value_type;
 #else
   typedef unsigned char ipv4_value_type;
 #endif
   typedef int ipv6_value_type;
 
@@ -272,25 +272,25 @@ public:
   // Construct with a specific option value.
   explicit multicast_hops(int v)
   {
     if (v < 0 || v > 255)
     {
       std::out_of_range ex("multicast hops value out of range");
-      boost::throw_exception(ex);
+      boost::asio::detail::throw_exception(ex);
     }
     ipv4_value_ = (ipv4_value_type)v;
     ipv6_value_ = v;
   }
 
   // Set the value of the option.
   multicast_hops& operator=(int v)
   {
     if (v < 0 || v > 255)
     {
       std::out_of_range ex("multicast hops value out of range");
-      boost::throw_exception(ex);
+      boost::asio::detail::throw_exception(ex);
     }
     ipv4_value_ = (ipv4_value_type)v;
     ipv6_value_ = v;
     return *this;
   }
 
@@ -351,13 +351,13 @@ public:
   {
     if (protocol.family() == PF_INET6)
     {
       if (s != sizeof(ipv6_value_))
       {
         std::length_error ex("multicast hops socket option resize");
-        boost::throw_exception(ex);
+        boost::asio::detail::throw_exception(ex);
       }
       if (ipv6_value_ < 0)
         ipv4_value_ = 0;
       else if (ipv6_value_ > 255)
         ipv4_value_ = 255;
       else
@@ -365,13 +365,13 @@ public:
     }
     else
     {
       if (s != sizeof(ipv4_value_))
       {
         std::length_error ex("multicast hops socket option resize");
-        boost::throw_exception(ex);
+        boost::asio::detail::throw_exception(ex);
       }
       ipv6_value_ = ipv4_value_;
     }
   }
 
 private:
@@ -399,13 +399,13 @@ public:
     if (multicast_address.is_v6())
     {
       using namespace std; // For memcpy.
       boost::asio::ip::address_v6 ipv6_address = multicast_address.to_v6();
       boost::asio::ip::address_v6::bytes_type bytes = ipv6_address.to_bytes();
       memcpy(ipv6_value_.ipv6mr_multiaddr.s6_addr, bytes.data(), 16);
-      ipv6_value_.ipv6mr_interface = 0;
+      ipv6_value_.ipv6mr_interface = ipv6_address.scope_id();
     }
     else
     {
       ipv4_value_.imr_multiaddr.s_addr =
         boost::asio::detail::socket_ops::host_to_network_long(
             multicast_address.to_v4().to_ulong());
@@ -437,13 +437,16 @@ public:
     : ipv4_value_() // Zero-initialisation gives the "any" address.
   {
     using namespace std; // For memcpy.
     boost::asio::ip::address_v6::bytes_type bytes =
       multicast_address.to_bytes();
     memcpy(ipv6_value_.ipv6mr_multiaddr.s6_addr, bytes.data(), 16);
-    ipv6_value_.ipv6mr_interface = network_interface;
+    if (network_interface)
+      ipv6_value_.ipv6mr_interface = network_interface;
+    else
+      ipv6_value_.ipv6mr_interface = multicast_address.scope_id();
   }
 
   // Get the level of the socket option.
   template <typename Protocol>
   int level(const Protocol& protocol) const
   {
diff --git a/3rdParty/Boost/src/boost/asio/ip/host_name.hpp b/3rdParty/Boost/src/boost/asio/ip/host_name.hpp
index 9e024e1..f38c1eb 100644
--- a/3rdParty/Boost/src/boost/asio/ip/host_name.hpp
+++ b/3rdParty/Boost/src/boost/asio/ip/host_name.hpp
@@ -1,11 +1,11 @@
 //
 // ip/host_name.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)
 //
 
 #ifndef BOOST_ASIO_IP_HOST_NAME_HPP
diff --git a/3rdParty/Boost/src/boost/asio/ip/icmp.hpp b/3rdParty/Boost/src/boost/asio/ip/icmp.hpp
index 62748b6..9849c88 100644
--- a/3rdParty/Boost/src/boost/asio/ip/icmp.hpp
+++ b/3rdParty/Boost/src/boost/asio/ip/icmp.hpp
@@ -1,11 +1,11 @@
 //
 // ip/icmp.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)
 //
 
 #ifndef BOOST_ASIO_IP_ICMP_HPP
@@ -46,25 +46,27 @@ public:
   /// The type of a ICMP endpoint.
   typedef basic_endpoint<icmp> endpoint;
 
   /// Construct to represent the IPv4 ICMP protocol.
   static icmp v4()
   {
-    return icmp(IPPROTO_ICMP, PF_INET);
+    return icmp(BOOST_ASIO_OS_DEF(IPPROTO_ICMP),
+        BOOST_ASIO_OS_DEF(AF_INET));
   }
 
   /// Construct to represent the IPv6 ICMP protocol.
   static icmp v6()
   {
-    return icmp(IPPROTO_ICMPV6, PF_INET6);
+    return icmp(BOOST_ASIO_OS_DEF(IPPROTO_ICMPV6),
+        BOOST_ASIO_OS_DEF(AF_INET6));
   }
 
   /// Obtain an identifier for the type of the protocol.
   int type() const
   {
-    return SOCK_RAW;
+    return BOOST_ASIO_OS_DEF(SOCK_RAW);
   }
 
   /// Obtain an identifier for the protocol.
   int protocol() const
   {
     return protocol_;
diff --git a/3rdParty/Boost/src/boost/asio/ip/impl/address.hpp b/3rdParty/Boost/src/boost/asio/ip/impl/address.hpp
index a875e1b..247e7d7 100644
--- a/3rdParty/Boost/src/boost/asio/ip/impl/address.hpp
+++ b/3rdParty/Boost/src/boost/asio/ip/impl/address.hpp
@@ -1,24 +1,24 @@
 //
 // ip/impl/address.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)
 //
 
 #ifndef BOOST_ASIO_IP_IMPL_ADDRESS_HPP
 #define BOOST_ASIO_IP_IMPL_ADDRESS_HPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
-#if !defined(BOOST_NO_IOSTREAM)
+#if !defined(BOOST_ASIO_NO_IOSTREAM)
 
 #include <boost/asio/detail/throw_error.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
@@ -47,9 +47,9 @@ std::basic_ostream<Elem, Traits>& operator<<(
 } // namespace ip
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
-#endif // !defined(BOOST_NO_IOSTREAM)
+#endif // !defined(BOOST_ASIO_NO_IOSTREAM)
 
 #endif // BOOST_ASIO_IP_IMPL_ADDRESS_HPP
diff --git a/3rdParty/Boost/src/boost/asio/ip/impl/address.ipp b/3rdParty/Boost/src/boost/asio/ip/impl/address.ipp
index 5353758..de57587 100644
--- a/3rdParty/Boost/src/boost/asio/ip/impl/address.ipp
+++ b/3rdParty/Boost/src/boost/asio/ip/impl/address.ipp
@@ -1,11 +1,11 @@
 //
 // ip/impl/address.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)
 //
 
 #ifndef BOOST_ASIO_IP_IMPL_ADDRESS_IPP
@@ -14,14 +14,14 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 #include <typeinfo>
-#include <boost/throw_exception.hpp>
 #include <boost/asio/detail/throw_error.hpp>
+#include <boost/asio/detail/throw_exception.hpp>
 #include <boost/asio/error.hpp>
 #include <boost/asio/ip/address.hpp>
 #include <boost/system/system_error.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
@@ -102,23 +102,23 @@ address& address::operator=(const boost::asio::ip::address_v6& ipv6_address)
 
 boost::asio::ip::address_v4 address::to_v4() const
 {
   if (type_ != ipv4)
   {
     std::bad_cast ex;
-    boost::throw_exception(ex);
+    boost::asio::detail::throw_exception(ex);
   }
   return ipv4_address_;
 }
 
 boost::asio::ip::address_v6 address::to_v6() const
 {
   if (type_ != ipv6)
   {
     std::bad_cast ex;
-    boost::throw_exception(ex);
+    boost::asio::detail::throw_exception(ex);
   }
   return ipv6_address_;
 }
 
 std::string address::to_string() const
 {
diff --git a/3rdParty/Boost/src/boost/asio/ip/impl/address_v4.hpp b/3rdParty/Boost/src/boost/asio/ip/impl/address_v4.hpp
index 87b0e19..857b546 100644
--- a/3rdParty/Boost/src/boost/asio/ip/impl/address_v4.hpp
+++ b/3rdParty/Boost/src/boost/asio/ip/impl/address_v4.hpp
@@ -1,24 +1,24 @@
 //
 // ip/impl/address_v4.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)
 //
 
 #ifndef BOOST_ASIO_IP_IMPL_ADDRESS_V4_HPP
 #define BOOST_ASIO_IP_IMPL_ADDRESS_V4_HPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
-#if !defined(BOOST_NO_IOSTREAM)
+#if !defined(BOOST_ASIO_NO_IOSTREAM)
 
 #include <boost/asio/detail/throw_error.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
@@ -47,9 +47,9 @@ std::basic_ostream<Elem, Traits>& operator<<(
 } // namespace ip
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
-#endif // !defined(BOOST_NO_IOSTREAM)
+#endif // !defined(BOOST_ASIO_NO_IOSTREAM)
 
 #endif // BOOST_ASIO_IP_IMPL_ADDRESS_V4_HPP
diff --git a/3rdParty/Boost/src/boost/asio/ip/impl/address_v4.ipp b/3rdParty/Boost/src/boost/asio/ip/impl/address_v4.ipp
index 31f6e27..a202901 100644
--- a/3rdParty/Boost/src/boost/asio/ip/impl/address_v4.ipp
+++ b/3rdParty/Boost/src/boost/asio/ip/impl/address_v4.ipp
@@ -1,11 +1,11 @@
 //
 // ip/impl/address_v4.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)
 //
 
 #ifndef BOOST_ASIO_IP_IMPL_ADDRESS_V4_IPP
@@ -15,16 +15,16 @@
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 #include <climits>
 #include <stdexcept>
-#include <boost/throw_exception.hpp>
 #include <boost/asio/error.hpp>
 #include <boost/asio/detail/socket_ops.hpp>
 #include <boost/asio/detail/throw_error.hpp>
+#include <boost/asio/detail/throw_exception.hpp>
 #include <boost/asio/ip/address_v4.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
@@ -34,13 +34,13 @@ address_v4::address_v4(const address_v4::bytes_type& bytes)
 {
 #if UCHAR_MAX > 0xFF
   if (bytes[0] > 0xFF || bytes[1] > 0xFF
       || bytes[2] > 0xFF || bytes[3] > 0xFF)
   {
     std::out_of_range ex("address_v4 from bytes_type");
-    boost::throw_exception(ex);
+    boost::asio::detail::throw_exception(ex);
   }
 #endif // UCHAR_MAX > 0xFF
 
   using namespace std; // For memcpy.
   memcpy(&addr_.s_addr, bytes.data(), 4);
 }
@@ -48,17 +48,18 @@ address_v4::address_v4(const address_v4::bytes_type& bytes)
 address_v4::address_v4(unsigned long addr)
 {
 #if ULONG_MAX > 0xFFFFFFFF
   if (addr > 0xFFFFFFFF)
   {
     std::out_of_range ex("address_v4 from unsigned long");
-    boost::throw_exception(ex);
+    boost::asio::detail::throw_exception(ex);
   }
 #endif // ULONG_MAX > 0xFFFFFFFF
 
-  addr_.s_addr = boost::asio::detail::socket_ops::host_to_network_long(addr);
+  addr_.s_addr = boost::asio::detail::socket_ops::host_to_network_long(
+      static_cast<boost::asio::detail::u_long_type>(addr));
 }
 
 address_v4::bytes_type address_v4::to_bytes() const
 {
   using namespace std; // For memcpy.
   bytes_type bytes;
@@ -84,13 +85,14 @@ std::string address_v4::to_string() const
 }
 
 std::string address_v4::to_string(boost::system::error_code& ec) const
 {
   char addr_str[boost::asio::detail::max_addr_v4_str_len];
   const char* addr =
-    boost::asio::detail::socket_ops::inet_ntop(AF_INET, &addr_, addr_str,
+    boost::asio::detail::socket_ops::inet_ntop(
+        BOOST_ASIO_OS_DEF(AF_INET), &addr_, addr_str,
         boost::asio::detail::max_addr_v4_str_len, 0, ec);
   if (addr == 0)
     return std::string();
   return addr;
 }
 
@@ -104,13 +106,13 @@ address_v4 address_v4::from_string(const char* str)
 
 address_v4 address_v4::from_string(
     const char* str, boost::system::error_code& ec)
 {
   address_v4 tmp;
   if (boost::asio::detail::socket_ops::inet_pton(
-        AF_INET, str, &tmp.addr_, 0, ec) <= 0)
+        BOOST_ASIO_OS_DEF(AF_INET), str, &tmp.addr_, 0, ec) <= 0)
     return address_v4();
   return tmp;
 }
 
 address_v4 address_v4::from_string(const std::string& str)
 {
diff --git a/3rdParty/Boost/src/boost/asio/ip/impl/address_v6.hpp b/3rdParty/Boost/src/boost/asio/ip/impl/address_v6.hpp
index 6993ef0..758d646 100644
--- a/3rdParty/Boost/src/boost/asio/ip/impl/address_v6.hpp
+++ b/3rdParty/Boost/src/boost/asio/ip/impl/address_v6.hpp
@@ -1,24 +1,24 @@
 //
 // ip/impl/address_v6.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)
 //
 
 #ifndef BOOST_ASIO_IP_IMPL_ADDRESS_V6_HPP
 #define BOOST_ASIO_IP_IMPL_ADDRESS_V6_HPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
-#if !defined(BOOST_NO_IOSTREAM)
+#if !defined(BOOST_ASIO_NO_IOSTREAM)
 
 #include <boost/asio/detail/throw_error.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
@@ -47,9 +47,9 @@ std::basic_ostream<Elem, Traits>& operator<<(
 } // namespace ip
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
-#endif // !defined(BOOST_NO_IOSTREAM)
+#endif // !defined(BOOST_ASIO_NO_IOSTREAM)
 
 #endif // BOOST_ASIO_IP_IMPL_ADDRESS_V6_HPP
diff --git a/3rdParty/Boost/src/boost/asio/ip/impl/address_v6.ipp b/3rdParty/Boost/src/boost/asio/ip/impl/address_v6.ipp
index 9bf9e96..33db76b 100644
--- a/3rdParty/Boost/src/boost/asio/ip/impl/address_v6.ipp
+++ b/3rdParty/Boost/src/boost/asio/ip/impl/address_v6.ipp
@@ -1,11 +1,11 @@
 //
 // ip/impl/address_v6.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)
 //
 
 #ifndef BOOST_ASIO_IP_IMPL_ADDRESS_V6_IPP
@@ -16,15 +16,15 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 #include <cstring>
 #include <stdexcept>
 #include <typeinfo>
-#include <boost/throw_exception.hpp>
 #include <boost/asio/detail/socket_ops.hpp>
 #include <boost/asio/detail/throw_error.hpp>
+#include <boost/asio/detail/throw_exception.hpp>
 #include <boost/asio/error.hpp>
 #include <boost/asio/ip/address_v6.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
@@ -44,13 +44,13 @@ address_v6::address_v6(const address_v6::bytes_type& bytes,
 #if UCHAR_MAX > 0xFF
   for (std::size_t i = 0; i < bytes.size(); ++i)
   {
     if (bytes[i] > 0xFF)
     {
       std::out_of_range ex("address_v6 from bytes_type");
-      boost::throw_exception(ex);
+      boost::asio::detail::throw_exception(ex);
     }
   }
 #endif // UCHAR_MAX > 0xFF
 
   using namespace std; // For memcpy.
   memcpy(addr_.s6_addr, bytes.data(), 16);
@@ -107,13 +107,14 @@ std::string address_v6::to_string() const
 }
 
 std::string address_v6::to_string(boost::system::error_code& ec) const
 {
   char addr_str[boost::asio::detail::max_addr_v6_str_len];
   const char* addr =
-    boost::asio::detail::socket_ops::inet_ntop(AF_INET6, &addr_, addr_str,
+    boost::asio::detail::socket_ops::inet_ntop(
+        BOOST_ASIO_OS_DEF(AF_INET6), &addr_, addr_str,
         boost::asio::detail::max_addr_v6_str_len, scope_id_, ec);
   if (addr == 0)
     return std::string();
   return addr;
 }
 
@@ -127,13 +128,13 @@ address_v6 address_v6::from_string(const char* str)
 
 address_v6 address_v6::from_string(
     const char* str, boost::system::error_code& ec)
 {
   address_v6 tmp;
   if (boost::asio::detail::socket_ops::inet_pton(
-        AF_INET6, str, &tmp.addr_, &tmp.scope_id_, ec) <= 0)
+        BOOST_ASIO_OS_DEF(AF_INET6), str, &tmp.addr_, &tmp.scope_id_, ec) <= 0)
     return address_v6();
   return tmp;
 }
 
 address_v6 address_v6::from_string(const std::string& str)
 {
@@ -148,13 +149,13 @@ address_v6 address_v6::from_string(
 
 address_v4 address_v6::to_v4() const
 {
   if (!is_v4_mapped() && !is_v4_compatible())
   {
     std::bad_cast ex;
-    boost::throw_exception(ex);
+    boost::asio::detail::throw_exception(ex);
   }
 
   address_v4::bytes_type v4_bytes = { { addr_.s6_addr[12],
     addr_.s6_addr[13], addr_.s6_addr[14], addr_.s6_addr[15] } };
   return address_v4(v4_bytes);
 }
diff --git a/3rdParty/Boost/src/boost/asio/ip/impl/basic_endpoint.hpp b/3rdParty/Boost/src/boost/asio/ip/impl/basic_endpoint.hpp
index 681d76e..ec9b1fa 100644
--- a/3rdParty/Boost/src/boost/asio/ip/impl/basic_endpoint.hpp
+++ b/3rdParty/Boost/src/boost/asio/ip/impl/basic_endpoint.hpp
@@ -1,24 +1,24 @@
 //
 // ip/impl/basic_endpoint.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)
 //
 
 #ifndef BOOST_ASIO_IP_IMPL_BASIC_ENDPOINT_HPP
 #define BOOST_ASIO_IP_IMPL_BASIC_ENDPOINT_HPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
-#if !defined(BOOST_NO_IOSTREAM)
+#if !defined(BOOST_ASIO_NO_IOSTREAM)
 
 #include <boost/asio/detail/throw_error.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
@@ -49,9 +49,9 @@ std::basic_ostream<Elem, Traits>& operator<<(
 } // namespace ip
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
-#endif // !defined(BOOST_NO_IOSTREAM)
+#endif // !defined(BOOST_ASIO_NO_IOSTREAM)
 
 #endif // BOOST_ASIO_IP_IMPL_BASIC_ENDPOINT_HPP
diff --git a/3rdParty/Boost/src/boost/asio/ip/impl/host_name.ipp b/3rdParty/Boost/src/boost/asio/ip/impl/host_name.ipp
index cbac039..0921242 100644
--- a/3rdParty/Boost/src/boost/asio/ip/impl/host_name.ipp
+++ b/3rdParty/Boost/src/boost/asio/ip/impl/host_name.ipp
@@ -1,11 +1,11 @@
 //
 // ip/impl/host_name.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)
 //
 
 #ifndef BOOST_ASIO_IP_IMPL_HOST_NAME_IPP
diff --git a/3rdParty/Boost/src/boost/asio/ip/multicast.hpp b/3rdParty/Boost/src/boost/asio/ip/multicast.hpp
index a0a3c41..c162aa0 100644
--- a/3rdParty/Boost/src/boost/asio/ip/multicast.hpp
+++ b/3rdParty/Boost/src/boost/asio/ip/multicast.hpp
@@ -1,11 +1,11 @@
 //
 // ip/multicast.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)
 //
 
 #ifndef BOOST_ASIO_IP_MULTICAST_HPP
@@ -45,13 +45,16 @@ namespace multicast {
  * SettableSocketOption.
  */
 #if defined(GENERATING_DOCUMENTATION)
 typedef implementation_defined join_group;
 #else
 typedef boost::asio::ip::detail::socket_option::multicast_request<
-  IPPROTO_IP, IP_ADD_MEMBERSHIP, IPPROTO_IPV6, IPV6_JOIN_GROUP> join_group;
+  BOOST_ASIO_OS_DEF(IPPROTO_IP),
+  BOOST_ASIO_OS_DEF(IP_ADD_MEMBERSHIP),
+  BOOST_ASIO_OS_DEF(IPPROTO_IPV6),
+  BOOST_ASIO_OS_DEF(IPV6_JOIN_GROUP)> join_group;
 #endif
 
 /// Socket option to leave a multicast group on a specified interface.
 /**
  * Implements the IPPROTO_IP/IP_DROP_MEMBERSHIP socket option.
  *
@@ -70,13 +73,16 @@ typedef boost::asio::ip::detail::socket_option::multicast_request<
  * SettableSocketOption.
  */
 #if defined(GENERATING_DOCUMENTATION)
 typedef implementation_defined leave_group;
 #else
 typedef boost::asio::ip::detail::socket_option::multicast_request<
-  IPPROTO_IP, IP_DROP_MEMBERSHIP, IPPROTO_IPV6, IPV6_LEAVE_GROUP> leave_group;
+  BOOST_ASIO_OS_DEF(IPPROTO_IP),
+  BOOST_ASIO_OS_DEF(IP_DROP_MEMBERSHIP),
+  BOOST_ASIO_OS_DEF(IPPROTO_IPV6),
+  BOOST_ASIO_OS_DEF(IPV6_LEAVE_GROUP)> leave_group;
 #endif
 
 /// Socket option for local interface to use for outgoing multicast packets.
 /**
  * Implements the IPPROTO_IP/IP_MULTICAST_IF socket option.
  *
@@ -95,14 +101,16 @@ typedef boost::asio::ip::detail::socket_option::multicast_request<
  * SettableSocketOption.
  */
 #if defined(GENERATING_DOCUMENTATION)
 typedef implementation_defined outbound_interface;
 #else
 typedef boost::asio::ip::detail::socket_option::network_interface<
-  IPPROTO_IP, IP_MULTICAST_IF, IPPROTO_IPV6, IPV6_MULTICAST_IF>
-  outbound_interface;
+  BOOST_ASIO_OS_DEF(IPPROTO_IP),
+  BOOST_ASIO_OS_DEF(IP_MULTICAST_IF),
+  BOOST_ASIO_OS_DEF(IPPROTO_IPV6),
+  BOOST_ASIO_OS_DEF(IPV6_MULTICAST_IF)> outbound_interface;
 #endif
 
 /// Socket option for time-to-live associated with outgoing multicast packets.
 /**
  * Implements the IPPROTO_IP/IP_MULTICAST_TTL socket option.
  *
@@ -129,13 +137,16 @@ typedef boost::asio::ip::detail::socket_option::network_interface<
  * GettableSocketOption, SettableSocketOption.
  */
 #if defined(GENERATING_DOCUMENTATION)
 typedef implementation_defined hops;
 #else
 typedef boost::asio::ip::detail::socket_option::multicast_hops<
-  IPPROTO_IP, IP_MULTICAST_TTL, IPPROTO_IPV6, IPV6_MULTICAST_HOPS> hops;
+  BOOST_ASIO_OS_DEF(IPPROTO_IP),
+  BOOST_ASIO_OS_DEF(IP_MULTICAST_TTL),
+  BOOST_ASIO_OS_DEF(IPPROTO_IPV6),
+  BOOST_ASIO_OS_DEF(IPV6_MULTICAST_HOPS)> hops;
 #endif
 
 /// Socket option determining whether outgoing multicast packets will be
 /// received on the same socket if it is a member of the multicast group.
 /**
  * Implements the IPPROTO_IP/IP_MULTICAST_LOOP socket option.
@@ -163,14 +174,16 @@ typedef boost::asio::ip::detail::socket_option::multicast_hops<
  * GettableSocketOption, SettableSocketOption.
  */
 #if defined(GENERATING_DOCUMENTATION)
 typedef implementation_defined enable_loopback;
 #else
 typedef boost::asio::ip::detail::socket_option::multicast_enable_loopback<
-  IPPROTO_IP, IP_MULTICAST_LOOP, IPPROTO_IPV6, IPV6_MULTICAST_LOOP>
-  enable_loopback;
+  BOOST_ASIO_OS_DEF(IPPROTO_IP),
+  BOOST_ASIO_OS_DEF(IP_MULTICAST_LOOP),
+  BOOST_ASIO_OS_DEF(IPPROTO_IPV6),
+  BOOST_ASIO_OS_DEF(IPV6_MULTICAST_LOOP)> enable_loopback;
 #endif
 
 } // namespace multicast
 } // namespace ip
 } // namespace asio
 } // namespace boost
diff --git a/3rdParty/Boost/src/boost/asio/ip/resolver_query_base.hpp b/3rdParty/Boost/src/boost/asio/ip/resolver_query_base.hpp
index 4e281a6..d53cd5b 100644
--- a/3rdParty/Boost/src/boost/asio/ip/resolver_query_base.hpp
+++ b/3rdParty/Boost/src/boost/asio/ip/resolver_query_base.hpp
@@ -1,11 +1,11 @@
 //
 // ip/resolver_query_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)
 //
 // 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_IP_RESOLVER_QUERY_BASE_HPP
@@ -13,13 +13,12 @@
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
-#include <boost/detail/workaround.hpp>
 #include <boost/asio/detail/socket_types.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
@@ -61,37 +60,19 @@ public:
   /// for the system. Only return IPv6 addresses if a non-loopback IPv6 address
   /// is configured for the system.
   static const flags address_configured = implementation_defined;
 #else
   enum flags
   {
-    canonical_name = AI_CANONNAME,
-    passive = AI_PASSIVE,
-    numeric_host = AI_NUMERICHOST,
-# if defined(AI_NUMERICSERV)
-    numeric_service = AI_NUMERICSERV,
-# else
-    numeric_service = 0,
-# endif
-    // Note: QNX Neutrino 6.3 defines AI_V4MAPPED, AI_ALL and AI_ADDRCONFIG but
-    // does not implement them. Therefore they are specifically excluded here.
-# if defined(AI_V4MAPPED) && !defined(__QNXNTO__)
-    v4_mapped = AI_V4MAPPED,
-# else
-    v4_mapped = 0,
-# endif
-# if defined(AI_ALL) && !defined(__QNXNTO__)
-    all_matching = AI_ALL,
-# else
-    all_matching = 0,
-# endif
-# if defined(AI_ADDRCONFIG) && !defined(__QNXNTO__)
-    address_configured = AI_ADDRCONFIG
-# else
-    address_configured = 0
-# endif
+    canonical_name = BOOST_ASIO_OS_DEF(AI_CANONNAME),
+    passive = BOOST_ASIO_OS_DEF(AI_PASSIVE),
+    numeric_host = BOOST_ASIO_OS_DEF(AI_NUMERICHOST),
+    numeric_service = BOOST_ASIO_OS_DEF(AI_NUMERICSERV),
+    v4_mapped = BOOST_ASIO_OS_DEF(AI_V4MAPPED),
+    all_matching = BOOST_ASIO_OS_DEF(AI_ALL),
+    address_configured = BOOST_ASIO_OS_DEF(AI_ADDRCONFIG)
   };
 
   // Implement bitmask operations as shown in C++ Std [lib.bitmask.types].
 
   friend flags operator&(flags x, flags y)
   {
@@ -110,13 +91,13 @@ public:
     return static_cast<flags>(
         static_cast<unsigned int>(x) ^ static_cast<unsigned int>(y));
   }
 
   friend flags operator~(flags x)
   {
-    return static_cast<flags>(static_cast<unsigned int>(~x));
+    return static_cast<flags>(~static_cast<unsigned int>(x));
   }
 
   friend flags& operator&=(flags& x, flags y)
   {
     x = x & y;
     return x;
@@ -137,18 +118,12 @@ public:
 
 protected:
   /// Protected destructor to prevent deletion through this type.
   ~resolver_query_base()
   {
   }
-
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
-private:
-  // Workaround to enable the empty base optimisation with Borland C++.
-  char dummy_;
-#endif
 };
 
 } // namespace ip
 } // namespace asio
 } // namespace boost
 
diff --git a/3rdParty/Boost/src/boost/asio/ip/resolver_service.hpp b/3rdParty/Boost/src/boost/asio/ip/resolver_service.hpp
index 74915d2..ec12007 100644
--- a/3rdParty/Boost/src/boost/asio/ip/resolver_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/ip/resolver_service.hpp
@@ -1,11 +1,11 @@
 //
 // ip/resolver_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)
 //
 
 #ifndef BOOST_ASIO_IP_RESOLVER_SERVICE_HPP
@@ -13,18 +13,24 @@
 
 #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/async_result.hpp>
 #include <boost/system/error_code.hpp>
-#include <boost/asio/detail/resolver_service.hpp>
 #include <boost/asio/io_service.hpp>
 #include <boost/asio/ip/basic_resolver_iterator.hpp>
 #include <boost/asio/ip/basic_resolver_query.hpp>
 
+#if defined(BOOST_ASIO_WINDOWS_RUNTIME)
+# include <boost/asio/detail/winrt_resolver_service.hpp>
+#else
+# include <boost/asio/detail/resolver_service.hpp>
+#endif
+
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace ip {
 
@@ -55,14 +61,19 @@ public:
 
   /// The iterator type.
   typedef basic_resolver_iterator<InternetProtocol> iterator_type;
 
 private:
   // The type of the platform-specific implementation.
+#if defined(BOOST_ASIO_WINDOWS_RUNTIME)
+  typedef boost::asio::detail::winrt_resolver_service<InternetProtocol>
+    service_impl_type;
+#else
   typedef boost::asio::detail::resolver_service<InternetProtocol>
     service_impl_type;
+#endif
 
 public:
   /// The type of a resolver implementation.
 #if defined(GENERATING_DOCUMENTATION)
   typedef implementation_defined implementation_type;
 #else
@@ -101,33 +112,47 @@ public:
   {
     return service_impl_.resolve(impl, query, ec);
   }
 
   /// Asynchronously resolve a query to a list of entries.
   template <typename ResolveHandler>
-  void async_resolve(implementation_type& impl, const query_type& query,
+  BOOST_ASIO_INITFN_RESULT_TYPE(ResolveHandler,
+      void (boost::system::error_code, iterator_type))
+  async_resolve(implementation_type& impl, const query_type& query,
       BOOST_ASIO_MOVE_ARG(ResolveHandler) handler)
   {
-    service_impl_.async_resolve(impl, query,
+    boost::asio::detail::async_result_init<
+      ResolveHandler, void (boost::system::error_code, iterator_type)> init(
         BOOST_ASIO_MOVE_CAST(ResolveHandler)(handler));
+
+    service_impl_.async_resolve(impl, query, init.handler);
+
+    return init.result.get();
   }
 
   /// Resolve an endpoint to a list of entries.
   iterator_type resolve(implementation_type& impl,
       const endpoint_type& endpoint, boost::system::error_code& ec)
   {
     return service_impl_.resolve(impl, endpoint, ec);
   }
 
   /// Asynchronously resolve an endpoint to a list of entries.
   template <typename ResolveHandler>
-  void async_resolve(implementation_type& impl, const endpoint_type& endpoint,
+  BOOST_ASIO_INITFN_RESULT_TYPE(ResolveHandler,
+      void (boost::system::error_code, iterator_type))
+  async_resolve(implementation_type& impl, const endpoint_type& endpoint,
       BOOST_ASIO_MOVE_ARG(ResolveHandler) handler)
   {
-    return service_impl_.async_resolve(impl, endpoint,
+    boost::asio::detail::async_result_init<
+      ResolveHandler, void (boost::system::error_code, iterator_type)> init(
         BOOST_ASIO_MOVE_CAST(ResolveHandler)(handler));
+
+    service_impl_.async_resolve(impl, endpoint, init.handler);
+
+    return init.result.get();
   }
 
 private:
   // Destroy all user-defined handler objects owned by the service.
   void shutdown_service()
   {
diff --git a/3rdParty/Boost/src/boost/asio/ip/tcp.hpp b/3rdParty/Boost/src/boost/asio/ip/tcp.hpp
index 0256e6f..efa5bf6 100644
--- a/3rdParty/Boost/src/boost/asio/ip/tcp.hpp
+++ b/3rdParty/Boost/src/boost/asio/ip/tcp.hpp
@@ -1,11 +1,11 @@
 //
 // ip/tcp.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)
 //
 
 #ifndef BOOST_ASIO_IP_TCP_HPP
@@ -49,31 +49,31 @@ public:
   /// The type of a TCP endpoint.
   typedef basic_endpoint<tcp> endpoint;
 
   /// Construct to represent the IPv4 TCP protocol.
   static tcp v4()
   {
-    return tcp(PF_INET);
+    return tcp(BOOST_ASIO_OS_DEF(AF_INET));
   }
 
   /// Construct to represent the IPv6 TCP protocol.
   static tcp v6()
   {
-    return tcp(PF_INET6);
+    return tcp(BOOST_ASIO_OS_DEF(AF_INET6));
   }
 
   /// Obtain an identifier for the type of the protocol.
   int type() const
   {
-    return SOCK_STREAM;
+    return BOOST_ASIO_OS_DEF(SOCK_STREAM);
   }
 
   /// Obtain an identifier for the protocol.
   int protocol() const
   {
-    return IPPROTO_TCP;
+    return BOOST_ASIO_OS_DEF(IPPROTO_TCP);
   }
 
   /// Obtain an identifier for the protocol family.
   int family() const
   {
     return family_;
@@ -85,16 +85,16 @@ public:
   /// The TCP acceptor type.
   typedef basic_socket_acceptor<tcp> acceptor;
 
   /// The TCP resolver type.
   typedef basic_resolver<tcp> resolver;
 
-#if !defined(BOOST_NO_IOSTREAM)
+#if !defined(BOOST_ASIO_NO_IOSTREAM)
   /// The TCP iostream type.
   typedef basic_socket_iostream<tcp> iostream;
-#endif // !defined(BOOST_NO_IOSTREAM)
+#endif // !defined(BOOST_ASIO_NO_IOSTREAM)
 
   /// Socket option for disabling the Nagle algorithm.
   /**
    * Implements the IPPROTO_TCP/TCP_NODELAY socket option.
    *
    * @par Examples
@@ -120,13 +120,13 @@ public:
    * Socket_Option, Boolean_Socket_Option.
    */
 #if defined(GENERATING_DOCUMENTATION)
   typedef implementation_defined no_delay;
 #else
   typedef boost::asio::detail::socket_option::boolean<
-    IPPROTO_TCP, TCP_NODELAY> no_delay;
+    BOOST_ASIO_OS_DEF(IPPROTO_TCP), BOOST_ASIO_OS_DEF(TCP_NODELAY)> no_delay;
 #endif
 
   /// Compare two protocols for equality.
   friend bool operator==(const tcp& p1, const tcp& p2)
   {
     return p1.family_ == p2.family_;
diff --git a/3rdParty/Boost/src/boost/asio/ip/udp.hpp b/3rdParty/Boost/src/boost/asio/ip/udp.hpp
index acf61ef..9eef435 100644
--- a/3rdParty/Boost/src/boost/asio/ip/udp.hpp
+++ b/3rdParty/Boost/src/boost/asio/ip/udp.hpp
@@ -1,11 +1,11 @@
 //
 // ip/udp.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)
 //
 
 #ifndef BOOST_ASIO_IP_UDP_HPP
@@ -46,31 +46,31 @@ public:
   /// The type of a UDP endpoint.
   typedef basic_endpoint<udp> endpoint;
 
   /// Construct to represent the IPv4 UDP protocol.
   static udp v4()
   {
-    return udp(PF_INET);
+    return udp(BOOST_ASIO_OS_DEF(AF_INET));
   }
 
   /// Construct to represent the IPv6 UDP protocol.
   static udp v6()
   {
-    return udp(PF_INET6);
+    return udp(BOOST_ASIO_OS_DEF(AF_INET6));
   }
 
   /// Obtain an identifier for the type of the protocol.
   int type() const
   {
-    return SOCK_DGRAM;
+    return BOOST_ASIO_OS_DEF(SOCK_DGRAM);
   }
 
   /// Obtain an identifier for the protocol.
   int protocol() const
   {
-    return IPPROTO_UDP;
+    return BOOST_ASIO_OS_DEF(IPPROTO_UDP);
   }
 
   /// Obtain an identifier for the protocol family.
   int family() const
   {
     return family_;
diff --git a/3rdParty/Boost/src/boost/asio/ip/unicast.hpp b/3rdParty/Boost/src/boost/asio/ip/unicast.hpp
index 5ff0dc8..59a03e2 100644
--- a/3rdParty/Boost/src/boost/asio/ip/unicast.hpp
+++ b/3rdParty/Boost/src/boost/asio/ip/unicast.hpp
@@ -1,11 +1,11 @@
 //
 // ip/unicast.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)
 //
 
 #ifndef BOOST_ASIO_IP_UNICAST_HPP
@@ -53,13 +53,16 @@ namespace unicast {
  * GettableSocketOption, SettableSocketOption.
  */
 #if defined(GENERATING_DOCUMENTATION)
 typedef implementation_defined hops;
 #else
 typedef boost::asio::ip::detail::socket_option::unicast_hops<
-  IPPROTO_IP, IP_TTL, IPPROTO_IPV6, IPV6_UNICAST_HOPS> hops;
+  BOOST_ASIO_OS_DEF(IPPROTO_IP),
+  BOOST_ASIO_OS_DEF(IP_TTL),
+  BOOST_ASIO_OS_DEF(IPPROTO_IPV6),
+  BOOST_ASIO_OS_DEF(IPV6_UNICAST_HOPS)> hops;
 #endif
 
 } // namespace unicast
 } // namespace ip
 } // namespace asio
 } // namespace boost
diff --git a/3rdParty/Boost/src/boost/asio/ip/v6_only.hpp b/3rdParty/Boost/src/boost/asio/ip/v6_only.hpp
index 0441991..6386e19 100644
--- a/3rdParty/Boost/src/boost/asio/ip/v6_only.hpp
+++ b/3rdParty/Boost/src/boost/asio/ip/v6_only.hpp
@@ -1,11 +1,11 @@
 //
 // ip/v6_only.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)
 //
 
 #ifndef BOOST_ASIO_IP_V6_ONLY_HPP
diff --git a/3rdParty/Boost/src/boost/asio/is_read_buffered.hpp b/3rdParty/Boost/src/boost/asio/is_read_buffered.hpp
index 8ad32e4..65c3aa9 100644
--- a/3rdParty/Boost/src/boost/asio/is_read_buffered.hpp
+++ b/3rdParty/Boost/src/boost/asio/is_read_buffered.hpp
@@ -1,11 +1,11 @@
 //
 // is_read_buffered.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)
 //
 
 #ifndef BOOST_ASIO_IS_READ_BUFFERED_HPP
@@ -45,13 +45,13 @@ class is_read_buffered
 public:
 #if defined(GENERATING_DOCUMENTATION)
   /// The value member is true only if the Stream type supports buffering of
   /// read data.
   static const bool value;
 #else
-  BOOST_STATIC_CONSTANT(bool,
+  BOOST_ASIO_STATIC_CONSTANT(bool,
       value = sizeof(detail::is_read_buffered_helper((Stream*)0)) == 1);
 #endif
 };
 
 } // namespace asio
 } // namespace boost
diff --git a/3rdParty/Boost/src/boost/asio/is_write_buffered.hpp b/3rdParty/Boost/src/boost/asio/is_write_buffered.hpp
index bbc2e22..964c299 100644
--- a/3rdParty/Boost/src/boost/asio/is_write_buffered.hpp
+++ b/3rdParty/Boost/src/boost/asio/is_write_buffered.hpp
@@ -1,11 +1,11 @@
 //
 // is_write_buffered.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)
 //
 
 #ifndef BOOST_ASIO_IS_WRITE_BUFFERED_HPP
@@ -45,13 +45,13 @@ class is_write_buffered
 public:
 #if defined(GENERATING_DOCUMENTATION)
   /// The value member is true only if the Stream type supports buffering of
   /// written data.
   static const bool value;
 #else
-  BOOST_STATIC_CONSTANT(bool,
+  BOOST_ASIO_STATIC_CONSTANT(bool,
       value = sizeof(detail::is_write_buffered_helper((Stream*)0)) == 1);
 #endif
 };
 
 } // namespace asio
 } // namespace boost
diff --git a/3rdParty/Boost/src/boost/asio/local/basic_endpoint.hpp b/3rdParty/Boost/src/boost/asio/local/basic_endpoint.hpp
index f191dd6..ec3d1f8 100644
--- a/3rdParty/Boost/src/boost/asio/local/basic_endpoint.hpp
+++ b/3rdParty/Boost/src/boost/asio/local/basic_endpoint.hpp
@@ -1,11 +1,11 @@
 //
 // local/basic_endpoint.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)
 // Derived from a public domain implementation written by Daniel Casimiro.
 //
 // 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)
 //
 
@@ -20,15 +20,15 @@
 
 #if defined(BOOST_ASIO_HAS_LOCAL_SOCKETS) \
   || defined(GENERATING_DOCUMENTATION)
 
 #include <boost/asio/local/detail/endpoint.hpp>
 
-#if !defined(BOOST_NO_IOSTREAM)
+#if !defined(BOOST_ASIO_NO_IOSTREAM)
 # include <iosfwd>
-#endif // !defined(BOOST_NO_IOSTREAM)
+#endif // !defined(BOOST_ASIO_NO_IOSTREAM)
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace local {
diff --git a/3rdParty/Boost/src/boost/asio/local/connect_pair.hpp b/3rdParty/Boost/src/boost/asio/local/connect_pair.hpp
index e691398..4b169b5 100644
--- a/3rdParty/Boost/src/boost/asio/local/connect_pair.hpp
+++ b/3rdParty/Boost/src/boost/asio/local/connect_pair.hpp
@@ -1,11 +1,11 @@
 //
 // local/connect_pair.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)
 //
 
 #ifndef BOOST_ASIO_LOCAL_CONNECT_PAIR_HPP
diff --git a/3rdParty/Boost/src/boost/asio/local/datagram_protocol.hpp b/3rdParty/Boost/src/boost/asio/local/datagram_protocol.hpp
index 6fa6323..ef6a779 100644
--- a/3rdParty/Boost/src/boost/asio/local/datagram_protocol.hpp
+++ b/3rdParty/Boost/src/boost/asio/local/datagram_protocol.hpp
@@ -1,11 +1,11 @@
 //
 // local/datagram_protocol.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)
 //
 
 #ifndef BOOST_ASIO_LOCAL_DATAGRAM_PROTOCOL_HPP
diff --git a/3rdParty/Boost/src/boost/asio/local/detail/endpoint.hpp b/3rdParty/Boost/src/boost/asio/local/detail/endpoint.hpp
index 998d371..e610204 100644
--- a/3rdParty/Boost/src/boost/asio/local/detail/endpoint.hpp
+++ b/3rdParty/Boost/src/boost/asio/local/detail/endpoint.hpp
@@ -1,11 +1,11 @@
 //
 // local/detail/endpoint.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)
 // Derived from a public domain implementation written by Daniel Casimiro.
 //
 // 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)
 //
 
diff --git a/3rdParty/Boost/src/boost/asio/local/detail/impl/endpoint.ipp b/3rdParty/Boost/src/boost/asio/local/detail/impl/endpoint.ipp
index 8e3d06a..c02ae67 100644
--- a/3rdParty/Boost/src/boost/asio/local/detail/impl/endpoint.ipp
+++ b/3rdParty/Boost/src/boost/asio/local/detail/impl/endpoint.ipp
@@ -1,11 +1,11 @@
 //
 // local/detail/impl/endpoint.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)
 // Derived from a public domain implementation written by Daniel Casimiro.
 //
 // 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)
 //
 
diff --git a/3rdParty/Boost/src/boost/asio/local/stream_protocol.hpp b/3rdParty/Boost/src/boost/asio/local/stream_protocol.hpp
index c747666..c60b63a 100644
--- a/3rdParty/Boost/src/boost/asio/local/stream_protocol.hpp
+++ b/3rdParty/Boost/src/boost/asio/local/stream_protocol.hpp
@@ -1,11 +1,11 @@
 //
 // local/stream_protocol.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)
 //
 
 #ifndef BOOST_ASIO_LOCAL_STREAM_PROTOCOL_HPP
@@ -71,16 +71,16 @@ public:
   /// The UNIX domain socket type.
   typedef basic_stream_socket<stream_protocol> socket;
 
   /// The UNIX domain acceptor type.
   typedef basic_socket_acceptor<stream_protocol> acceptor;
 
-#if !defined(BOOST_NO_IOSTREAM)
+#if !defined(BOOST_ASIO_NO_IOSTREAM)
   /// The UNIX domain iostream type.
   typedef basic_socket_iostream<stream_protocol> iostream;
-#endif // !defined(BOOST_NO_IOSTREAM)
+#endif // !defined(BOOST_ASIO_NO_IOSTREAM)
 };
 
 } // namespace local
 } // namespace asio
 } // namespace boost
 
diff --git a/3rdParty/Boost/src/boost/asio/placeholders.hpp b/3rdParty/Boost/src/boost/asio/placeholders.hpp
index d4bf743..06a093f 100644
--- a/3rdParty/Boost/src/boost/asio/placeholders.hpp
+++ b/3rdParty/Boost/src/boost/asio/placeholders.hpp
@@ -1,11 +1,11 @@
 //
 // placeholders.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)
 //
 
 #ifndef BOOST_ASIO_PLACEHOLDERS_HPP
@@ -13,14 +13,16 @@
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
-#include <boost/bind/arg.hpp>
-#include <boost/detail/workaround.hpp>
+
+#if defined(BOOST_ASIO_HAS_BOOST_BIND)
+# include <boost/bind/arg.hpp>
+#endif // defined(BOOST_ASIO_HAS_BOOST_BIND)
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace placeholders {
@@ -44,13 +46,14 @@ unspecified iterator;
 
 /// An argument placeholder, for use with boost::bind(), that corresponds to
 /// the signal_number argument of a handler for asynchronous functions such as
 /// boost::asio::signal_set::async_wait.
 unspecified signal_number;
 
-#elif defined(__BORLANDC__) || defined(__GNUC__)
+#elif defined(BOOST_ASIO_HAS_BOOST_BIND)
+# if defined(__BORLANDC__) || defined(__GNUC__)
 
 inline boost::arg<1> error()
 {
   return boost::arg<1>();
 }
 
@@ -66,13 +69,13 @@ inline boost::arg<2> iterator()
 
 inline boost::arg<2> signal_number()
 {
   return boost::arg<2>();
 }
 
-#else
+# else
 
 namespace detail
 {
   template <int Number>
   struct placeholder
   {
@@ -81,24 +84,24 @@ namespace detail
       static boost::arg<Number> result;
       return result;
     }
   };
 }
 
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1400)
+#  if defined(BOOST_ASIO_MSVC) && (BOOST_ASIO_MSVC < 1400)
 
 static boost::arg<1>& error
   = boost::asio::placeholders::detail::placeholder<1>::get();
 static boost::arg<2>& bytes_transferred
   = boost::asio::placeholders::detail::placeholder<2>::get();
 static boost::arg<2>& iterator
   = boost::asio::placeholders::detail::placeholder<2>::get();
 static boost::arg<2>& signal_number
   = boost::asio::placeholders::detail::placeholder<2>::get();
 
-#else
+#  else
 
 namespace
 {
   boost::arg<1>& error
     = boost::asio::placeholders::detail::placeholder<1>::get();
   boost::arg<2>& bytes_transferred
@@ -106,14 +109,14 @@ namespace
   boost::arg<2>& iterator
     = boost::asio::placeholders::detail::placeholder<2>::get();
   boost::arg<2>& signal_number
     = boost::asio::placeholders::detail::placeholder<2>::get();
 } // namespace
 
-#endif
-
+#  endif
+# endif
 #endif
 
 } // namespace placeholders
 } // namespace asio
 } // namespace boost
 
diff --git a/3rdParty/Boost/src/boost/asio/posix/basic_descriptor.hpp b/3rdParty/Boost/src/boost/asio/posix/basic_descriptor.hpp
index d4af5a4..81a91c4 100644
--- a/3rdParty/Boost/src/boost/asio/posix/basic_descriptor.hpp
+++ b/3rdParty/Boost/src/boost/asio/posix/basic_descriptor.hpp
@@ -1,11 +1,11 @@
 //
 // posix/basic_descriptor.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)
 //
 
 #ifndef BOOST_ASIO_POSIX_BASIC_DESCRIPTOR_HPP
diff --git a/3rdParty/Boost/src/boost/asio/posix/basic_stream_descriptor.hpp b/3rdParty/Boost/src/boost/asio/posix/basic_stream_descriptor.hpp
index 2e8ed4b..7a3a921 100644
--- a/3rdParty/Boost/src/boost/asio/posix/basic_stream_descriptor.hpp
+++ b/3rdParty/Boost/src/boost/asio/posix/basic_stream_descriptor.hpp
@@ -1,11 +1,11 @@
 //
 // posix/basic_stream_descriptor.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)
 //
 
 #ifndef BOOST_ASIO_POSIX_BASIC_STREAM_DESCRIPTOR_HPP
@@ -222,20 +222,22 @@ public:
    * @endcode
    * See the @ref buffer documentation for information on writing multiple
    * buffers in one go, and how to use it with arrays, boost::array or
    * std::vector.
    */
   template <typename ConstBufferSequence, typename WriteHandler>
-  void async_write_some(const ConstBufferSequence& buffers,
+  BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,
+      void (boost::system::error_code, std::size_t))
+  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;
 
-    this->get_service().async_write_some(this->get_implementation(),
+    return this->get_service().async_write_some(this->get_implementation(),
         buffers, BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
   }
 
   /// Read some data from the descriptor.
   /**
    * This function is used to read data from the stream descriptor. The function
@@ -333,20 +335,22 @@ public:
    * @endcode
    * See the @ref buffer documentation for information on reading into multiple
    * buffers in one go, and how to use it with arrays, boost::array or
    * std::vector.
    */
   template <typename MutableBufferSequence, typename ReadHandler>
-  void async_read_some(const MutableBufferSequence& buffers,
+  BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+      void (boost::system::error_code, std::size_t))
+  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;
 
-    this->get_service().async_read_some(this->get_implementation(),
+    return this->get_service().async_read_some(this->get_implementation(),
         buffers, BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
   }
 };
 
 } // namespace posix
 } // namespace asio
diff --git a/3rdParty/Boost/src/boost/asio/posix/descriptor_base.hpp b/3rdParty/Boost/src/boost/asio/posix/descriptor_base.hpp
index c75b85a..8cfc0e6 100644
--- a/3rdParty/Boost/src/boost/asio/posix/descriptor_base.hpp
+++ b/3rdParty/Boost/src/boost/asio/posix/descriptor_base.hpp
@@ -1,11 +1,11 @@
 //
 // posix/descriptor_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)
 //
 // 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_POSIX_DESCRIPTOR_BASE_HPP
diff --git a/3rdParty/Boost/src/boost/asio/posix/stream_descriptor.hpp b/3rdParty/Boost/src/boost/asio/posix/stream_descriptor.hpp
index 9078107..5a2e5fb 100644
--- a/3rdParty/Boost/src/boost/asio/posix/stream_descriptor.hpp
+++ b/3rdParty/Boost/src/boost/asio/posix/stream_descriptor.hpp
@@ -1,11 +1,11 @@
 //
 // posix/stream_descriptor.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)
 //
 
 #ifndef BOOST_ASIO_POSIX_STREAM_DESCRIPTOR_HPP
diff --git a/3rdParty/Boost/src/boost/asio/posix/stream_descriptor_service.hpp b/3rdParty/Boost/src/boost/asio/posix/stream_descriptor_service.hpp
index 0daa21a..50a27e9 100644
--- a/3rdParty/Boost/src/boost/asio/posix/stream_descriptor_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/posix/stream_descriptor_service.hpp
@@ -1,11 +1,11 @@
 //
 // posix/stream_descriptor_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)
 //
 
 #ifndef BOOST_ASIO_POSIX_STREAM_DESCRIPTOR_SERVICE_HPP
@@ -18,12 +18,13 @@
 #include <boost/asio/detail/config.hpp>
 
 #if defined(BOOST_ASIO_HAS_POSIX_STREAM_DESCRIPTOR) \
   || defined(GENERATING_DOCUMENTATION)
 
 #include <cstddef>
+#include <boost/asio/async_result.hpp>
 #include <boost/asio/error.hpp>
 #include <boost/asio/io_service.hpp>
 #include <boost/asio/detail/reactive_descriptor_service.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
@@ -195,36 +196,50 @@ public:
   {
     return service_impl_.write_some(impl, buffers, ec);
   }
 
   /// Start an asynchronous write.
   template <typename ConstBufferSequence, typename WriteHandler>
-  void async_write_some(implementation_type& impl,
+  BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,
+      void (boost::system::error_code, std::size_t))
+  async_write_some(implementation_type& impl,
       const ConstBufferSequence& buffers,
       BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
   {
-    service_impl_.async_write_some(impl, buffers,
+    boost::asio::detail::async_result_init<
+      WriteHandler, void (boost::system::error_code, std::size_t)> init(
         BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
+
+    service_impl_.async_write_some(impl, buffers, init.handler);
+
+    return init.result.get();
   }
 
   /// Read some data from the stream.
   template <typename MutableBufferSequence>
   std::size_t read_some(implementation_type& impl,
       const MutableBufferSequence& buffers, boost::system::error_code& ec)
   {
     return service_impl_.read_some(impl, buffers, ec);
   }
 
   /// Start an asynchronous read.
   template <typename MutableBufferSequence, typename ReadHandler>
-  void async_read_some(implementation_type& impl,
+  BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+      void (boost::system::error_code, std::size_t))
+  async_read_some(implementation_type& impl,
       const MutableBufferSequence& buffers,
       BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
   {
-    service_impl_.async_read_some(impl, buffers,
+    boost::asio::detail::async_result_init<
+      ReadHandler, void (boost::system::error_code, std::size_t)> init(
         BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
+
+    service_impl_.async_read_some(impl, buffers, init.handler);
+
+    return init.result.get();
   }
 
 private:
   // Destroy all user-defined handler objects owned by the service.
   void shutdown_service()
   {
diff --git a/3rdParty/Boost/src/boost/asio/raw_socket_service.hpp b/3rdParty/Boost/src/boost/asio/raw_socket_service.hpp
index cd8aa04..c412e0a 100644
--- a/3rdParty/Boost/src/boost/asio/raw_socket_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/raw_socket_service.hpp
@@ -1,11 +1,11 @@
 //
 // raw_socket_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)
 //
 
 #ifndef BOOST_ASIO_RAW_SOCKET_SERVICE_HPP
@@ -14,16 +14,20 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 #include <cstddef>
+#include <boost/asio/async_result.hpp>
+#include <boost/asio/detail/type_traits.hpp>
 #include <boost/asio/error.hpp>
 #include <boost/asio/io_service.hpp>
 
-#if defined(BOOST_ASIO_HAS_IOCP)
+#if defined(BOOST_ASIO_WINDOWS_RUNTIME)
+# include <boost/asio/detail/null_socket_service.hpp>
+#elif defined(BOOST_ASIO_HAS_IOCP)
 # include <boost/asio/detail/win_iocp_socket_service.hpp>
 #else
 # include <boost/asio/detail/reactive_socket_service.hpp>
 #endif
 
 #include <boost/asio/detail/push_options.hpp>
@@ -51,13 +55,15 @@ public:
 
   /// The endpoint type.
   typedef typename Protocol::endpoint endpoint_type;
 
 private:
   // The type of the platform-specific implementation.
-#if defined(BOOST_ASIO_HAS_IOCP)
+#if defined(BOOST_ASIO_WINDOWS_RUNTIME)
+  typedef detail::null_socket_service<Protocol> service_impl_type;
+#elif defined(BOOST_ASIO_HAS_IOCP)
   typedef detail::win_iocp_socket_service<Protocol> service_impl_type;
 #else
   typedef detail::reactive_socket_service<Protocol> service_impl_type;
 #endif
 
 public:
@@ -108,25 +114,38 @@ public:
   void move_assign(implementation_type& impl,
       raw_socket_service& other_service,
       implementation_type& other_impl)
   {
     service_impl_.move_assign(impl, other_service.service_impl_, other_impl);
   }
+
+  /// Move-construct a new raw socket implementation from another protocol
+  /// type.
+  template <typename Protocol1>
+  void converting_move_construct(implementation_type& impl,
+      typename raw_socket_service<
+        Protocol1>::implementation_type& other_impl,
+      typename enable_if<is_convertible<
+        Protocol1, Protocol>::value>::type* = 0)
+  {
+    service_impl_.template converting_move_construct<Protocol1>(
+        impl, other_impl);
+  }
 #endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
 
   /// Destroy a raw socket implementation.
   void destroy(implementation_type& impl)
   {
     service_impl_.destroy(impl);
   }
 
   // Open a new raw socket implementation.
   boost::system::error_code open(implementation_type& impl,
       const protocol_type& protocol, boost::system::error_code& ec)
   {
-    if (protocol.type() == SOCK_RAW)
+    if (protocol.type() == BOOST_ASIO_OS_DEF(SOCK_RAW))
       service_impl_.open(impl, protocol, ec);
     else
       ec = boost::asio::error::invalid_argument;
     return ec;
   }
 
@@ -197,18 +216,25 @@ public:
   {
     return service_impl_.connect(impl, peer_endpoint, ec);
   }
 
   /// Start an asynchronous connect.
   template <typename ConnectHandler>
-  void async_connect(implementation_type& impl,
+  BOOST_ASIO_INITFN_RESULT_TYPE(ConnectHandler,
+      void (boost::system::error_code))
+  async_connect(implementation_type& impl,
       const endpoint_type& peer_endpoint,
       BOOST_ASIO_MOVE_ARG(ConnectHandler) handler)
   {
-    service_impl_.async_connect(impl, peer_endpoint,
+    detail::async_result_init<
+      ConnectHandler, void (boost::system::error_code)> init(
         BOOST_ASIO_MOVE_CAST(ConnectHandler)(handler));
+
+    service_impl_.async_connect(impl, peer_endpoint, init.handler);
+
+    return init.result.get();
   }
 
   /// Set a socket option.
   template <typename SettableSocketOption>
   boost::system::error_code set_option(implementation_type& impl,
       const SettableSocketOption& option, boost::system::error_code& ec)
@@ -287,18 +313,25 @@ public:
   {
     return service_impl_.send(impl, buffers, flags, ec);
   }
 
   /// Start an asynchronous send.
   template <typename ConstBufferSequence, typename WriteHandler>
-  void async_send(implementation_type& impl, const ConstBufferSequence& buffers,
+  BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,
+      void (boost::system::error_code, std::size_t))
+  async_send(implementation_type& impl, const ConstBufferSequence& buffers,
       socket_base::message_flags flags,
       BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
   {
-    service_impl_.async_send(impl, buffers, flags,
+    detail::async_result_init<
+      WriteHandler, void (boost::system::error_code, std::size_t)> init(
         BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
+
+    service_impl_.async_send(impl, buffers, flags, init.handler);
+
+    return init.result.get();
   }
 
   /// Send raw data to the specified endpoint.
   template <typename ConstBufferSequence>
   std::size_t send_to(implementation_type& impl,
       const ConstBufferSequence& buffers, const endpoint_type& destination,
@@ -306,19 +339,27 @@ public:
   {
     return service_impl_.send_to(impl, buffers, destination, flags, ec);
   }
 
   /// Start an asynchronous send.
   template <typename ConstBufferSequence, typename WriteHandler>
-  void async_send_to(implementation_type& impl,
+  BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,
+      void (boost::system::error_code, std::size_t))
+  async_send_to(implementation_type& impl,
       const ConstBufferSequence& buffers, const endpoint_type& destination,
       socket_base::message_flags flags,
       BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
   {
-    service_impl_.async_send_to(impl, buffers, destination, flags,
+    detail::async_result_init<
+      WriteHandler, void (boost::system::error_code, std::size_t)> init(
         BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
+
+    service_impl_.async_send_to(impl, buffers,
+        destination, flags, init.handler);
+
+    return init.result.get();
   }
 
   /// Receive some data from the peer.
   template <typename MutableBufferSequence>
   std::size_t receive(implementation_type& impl,
       const MutableBufferSequence& buffers,
@@ -326,19 +367,26 @@ public:
   {
     return service_impl_.receive(impl, buffers, flags, ec);
   }
 
   /// Start an asynchronous receive.
   template <typename MutableBufferSequence, typename ReadHandler>
-  void async_receive(implementation_type& impl,
+  BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+      void (boost::system::error_code, std::size_t))
+  async_receive(implementation_type& impl,
       const MutableBufferSequence& buffers,
       socket_base::message_flags flags,
       BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
   {
-    service_impl_.async_receive(impl, buffers, flags,
+    detail::async_result_init<
+      ReadHandler, void (boost::system::error_code, std::size_t)> init(
         BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
+
+    service_impl_.async_receive(impl, buffers, flags, init.handler);
+
+    return init.result.get();
   }
 
   /// Receive raw data with the endpoint of the sender.
   template <typename MutableBufferSequence>
   std::size_t receive_from(implementation_type& impl,
       const MutableBufferSequence& buffers, endpoint_type& sender_endpoint,
@@ -347,19 +395,27 @@ public:
     return service_impl_.receive_from(impl, buffers, sender_endpoint, flags,
         ec);
   }
 
   /// Start an asynchronous receive that will get the endpoint of the sender.
   template <typename MutableBufferSequence, typename ReadHandler>
-  void async_receive_from(implementation_type& impl,
+  BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+      void (boost::system::error_code, std::size_t))
+  async_receive_from(implementation_type& impl,
       const MutableBufferSequence& buffers, endpoint_type& sender_endpoint,
       socket_base::message_flags flags,
       BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
   {
-    service_impl_.async_receive_from(impl, buffers, sender_endpoint, flags,
+    detail::async_result_init<
+      ReadHandler, void (boost::system::error_code, std::size_t)> init(
         BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
+
+    service_impl_.async_receive_from(impl, buffers,
+        sender_endpoint, flags, init.handler);
+
+    return init.result.get();
   }
 
 private:
   // Destroy all user-defined handler objects owned by the service.
   void shutdown_service()
   {
diff --git a/3rdParty/Boost/src/boost/asio/read.hpp b/3rdParty/Boost/src/boost/asio/read.hpp
index 937dccd..20fea0b 100644
--- a/3rdParty/Boost/src/boost/asio/read.hpp
+++ b/3rdParty/Boost/src/boost/asio/read.hpp
@@ -1,11 +1,11 @@
 //
 // 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)
 //
 
 #ifndef BOOST_ASIO_READ_HPP
@@ -14,12 +14,13 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 #include <cstddef>
+#include <boost/asio/async_result.hpp>
 #include <boost/asio/basic_streambuf_fwd.hpp>
 #include <boost/asio/error.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
@@ -204,13 +205,13 @@ std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
  */
 template <typename SyncReadStream, typename MutableBufferSequence,
     typename CompletionCondition>
 std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
     CompletionCondition completion_condition, boost::system::error_code& ec);
 
-#if !defined(BOOST_NO_IOSTREAM)
+#if !defined(BOOST_ASIO_NO_IOSTREAM)
 
 /// Attempt to read a certain amount of data from a stream before returning.
 /**
  * This function is used to read a certain number of bytes of data from a
  * stream. The call will block until one of the following conditions is true:
  *
@@ -346,13 +347,13 @@ std::size_t read(SyncReadStream& s, basic_streambuf<Allocator>& b,
  */
 template <typename SyncReadStream, typename Allocator,
     typename CompletionCondition>
 std::size_t read(SyncReadStream& s, basic_streambuf<Allocator>& b,
     CompletionCondition completion_condition, boost::system::error_code& ec);
 
-#endif // !defined(BOOST_NO_IOSTREAM)
+#endif // !defined(BOOST_ASIO_NO_IOSTREAM)
 
 /*@}*/
 /**
  * @defgroup async_read boost::asio::async_read
  *
  * @brief Start an asynchronous operation to read a certain amount of data from
@@ -419,13 +420,15 @@ std::size_t read(SyncReadStream& s, basic_streambuf<Allocator>& b,
  *     s, buffers,
  *     boost::asio::transfer_all(),
  *     handler); @endcode
  */
 template <typename AsyncReadStream, typename MutableBufferSequence,
     typename ReadHandler>
-void async_read(AsyncReadStream& s, const MutableBufferSequence& buffers,
+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);
 
 /// Start an asynchronous operation to read a certain amount of data from a
 /// stream.
 /**
  * This function is used to asynchronously read a certain number of bytes of
@@ -487,17 +490,19 @@ void async_read(AsyncReadStream& s, const MutableBufferSequence& buffers,
  * See the @ref buffer documentation for information on reading into multiple
  * buffers in one go, and how to use it with arrays, boost::array or
  * std::vector.
  */
 template <typename AsyncReadStream, typename MutableBufferSequence,
     typename CompletionCondition, typename ReadHandler>
-void async_read(AsyncReadStream& s, const MutableBufferSequence& buffers,
+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);
 
-#if !defined(BOOST_NO_IOSTREAM)
+#if !defined(BOOST_ASIO_NO_IOSTREAM)
 
 /// Start an asynchronous operation to read a certain amount of data from a
 /// stream.
 /**
  * This function is used to asynchronously read a certain number of bytes of
  * data from a stream. The function call always returns immediately. The
@@ -542,13 +547,15 @@ void async_read(AsyncReadStream& s, const MutableBufferSequence& buffers,
  * @code boost::asio::async_read(
  *     s, b,
  *     boost::asio::transfer_all(),
  *     handler); @endcode
  */
 template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
-void async_read(AsyncReadStream& s, basic_streambuf<Allocator>& b,
+BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+    void (boost::system::error_code, std::size_t))
+async_read(AsyncReadStream& s, basic_streambuf<Allocator>& b,
     BOOST_ASIO_MOVE_ARG(ReadHandler) handler);
 
 /// Start an asynchronous operation to read a certain amount of data from a
 /// stream.
 /**
  * This function is used to asynchronously read a certain number of bytes of
@@ -603,17 +610,19 @@ void async_read(AsyncReadStream& s, basic_streambuf<Allocator>& b,
  * not, the handler will not be invoked from within this function. Invocation of
  * the handler will be performed in a manner equivalent to using
  * boost::asio::io_service::post().
  */
 template <typename AsyncReadStream, typename Allocator,
     typename CompletionCondition, typename ReadHandler>
-void async_read(AsyncReadStream& s, basic_streambuf<Allocator>& b,
+BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+    void (boost::system::error_code, std::size_t))
+async_read(AsyncReadStream& s, basic_streambuf<Allocator>& b,
     CompletionCondition completion_condition,
     BOOST_ASIO_MOVE_ARG(ReadHandler) handler);
 
-#endif // !defined(BOOST_NO_IOSTREAM)
+#endif // !defined(BOOST_ASIO_NO_IOSTREAM)
 
 /*@}*/
 
 } // namespace asio
 } // namespace boost
 
diff --git a/3rdParty/Boost/src/boost/asio/read_at.hpp b/3rdParty/Boost/src/boost/asio/read_at.hpp
index 7eb30e0..02acbee 100644
--- a/3rdParty/Boost/src/boost/asio/read_at.hpp
+++ b/3rdParty/Boost/src/boost/asio/read_at.hpp
@@ -1,11 +1,11 @@
 //
 // 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)
 //
 
 #ifndef BOOST_ASIO_READ_AT_HPP
@@ -14,14 +14,15 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 #include <cstddef>
-#include <boost/cstdint.hpp>
+#include <boost/asio/async_result.hpp>
 #include <boost/asio/basic_streambuf_fwd.hpp>
+#include <boost/asio/detail/cstdint.hpp>
 #include <boost/asio/error.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
@@ -73,13 +74,13 @@ namespace asio {
  * @code boost::asio::read_at(
  *     d, 42, buffers,
  *     boost::asio::transfer_all()); @endcode
  */
 template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence>
 std::size_t read_at(SyncRandomAccessReadDevice& d,
-    boost::uint64_t offset, const MutableBufferSequence& buffers);
+    uint64_t offset, const MutableBufferSequence& buffers);
 
 /// Attempt to read a certain amount of data at the specified offset before
 /// returning.
 /**
  * This function is used to read a certain number of bytes of data from a
  * random access device at the specified offset. The call will block until one
@@ -118,13 +119,13 @@ std::size_t read_at(SyncRandomAccessReadDevice& d,
  * @code boost::asio::read_at(
  *     d, 42, buffers,
  *     boost::asio::transfer_all(), ec); @endcode
  */
 template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence>
 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);
 
 /// Attempt to read a certain amount of data at the specified offset before
 /// returning.
 /**
  * This function is used to read a certain number of bytes of data from a
@@ -174,13 +175,13 @@ std::size_t read_at(SyncRandomAccessReadDevice& d,
  * buffers in one go, and how to use it with arrays, boost::array or
  * std::vector.
  */
 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);
 
 /// Attempt to read a certain amount of data at the specified offset before
 /// returning.
 /**
  * This function is used to read a certain number of bytes of data from a
@@ -223,16 +224,16 @@ std::size_t read_at(SyncRandomAccessReadDevice& d,
  * @returns The number of bytes read. If an error occurs, returns the total
  * number of bytes successfully transferred prior to the error.
  */
 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);
 
-#if !defined(BOOST_NO_IOSTREAM)
+#if !defined(BOOST_ASIO_NO_IOSTREAM)
 
 /// Attempt to read a certain amount of data at the specified offset before
 /// returning.
 /**
  * This function is used to read a certain number of bytes of data from a
  * random access device at the specified offset. The call will block until one
@@ -258,13 +259,13 @@ std::size_t read_at(SyncRandomAccessReadDevice& d,
  * @code boost::asio::read_at(
  *     d, 42, b,
  *     boost::asio::transfer_all()); @endcode
  */
 template <typename SyncRandomAccessReadDevice, typename Allocator>
 std::size_t read_at(SyncRandomAccessReadDevice& d,
-    boost::uint64_t offset, basic_streambuf<Allocator>& b);
+    uint64_t offset, basic_streambuf<Allocator>& b);
 
 /// Attempt to read a certain amount of data at the specified offset before
 /// returning.
 /**
  * This function is used to read a certain number of bytes of data from a
  * random access device at the specified offset. The call will block until one
@@ -290,13 +291,13 @@ std::size_t read_at(SyncRandomAccessReadDevice& d,
  * @code boost::asio::read_at(
  *     d, 42, b,
  *     boost::asio::transfer_all(), ec); @endcode
  */
 template <typename SyncRandomAccessReadDevice, typename Allocator>
 std::size_t read_at(SyncRandomAccessReadDevice& d,
-    boost::uint64_t offset, basic_streambuf<Allocator>& b,
+    uint64_t offset, basic_streambuf<Allocator>& b,
     boost::system::error_code& ec);
 
 /// Attempt to read a certain amount of data at the specified offset before
 /// returning.
 /**
  * This function is used to read a certain number of bytes of data from a
@@ -333,13 +334,13 @@ std::size_t read_at(SyncRandomAccessReadDevice& d,
  *
  * @throws boost::system::system_error Thrown on failure.
  */
 template <typename SyncRandomAccessReadDevice, typename Allocator,
     typename CompletionCondition>
 std::size_t read_at(SyncRandomAccessReadDevice& d,
-    boost::uint64_t offset, basic_streambuf<Allocator>& b,
+    uint64_t offset, basic_streambuf<Allocator>& b,
     CompletionCondition completion_condition);
 
 /// Attempt to read a certain amount of data at the specified offset before
 /// returning.
 /**
  * This function is used to read a certain number of bytes of data from a
@@ -377,16 +378,16 @@ std::size_t read_at(SyncRandomAccessReadDevice& d,
  * @returns The number of bytes read. If an error occurs, returns the total
  * number of bytes successfully transferred prior to the error.
  */
 template <typename SyncRandomAccessReadDevice, typename Allocator,
     typename CompletionCondition>
 std::size_t read_at(SyncRandomAccessReadDevice& d,
-    boost::uint64_t offset, basic_streambuf<Allocator>& b,
+    uint64_t offset, basic_streambuf<Allocator>& b,
     CompletionCondition completion_condition, boost::system::error_code& ec);
 
-#endif // !defined(BOOST_NO_IOSTREAM)
+#endif // !defined(BOOST_ASIO_NO_IOSTREAM)
 
 /*@}*/
 /**
  * @defgroup async_read_at boost::asio::async_read_at
  *
  * @brief Start an asynchronous operation to read a certain amount of data at
@@ -452,13 +453,15 @@ std::size_t read_at(SyncRandomAccessReadDevice& d,
  *     d, 42, buffers,
  *     boost::asio::transfer_all(),
  *     handler); @endcode
  */
 template <typename AsyncRandomAccessReadDevice, typename MutableBufferSequence,
     typename ReadHandler>
-void async_read_at(AsyncRandomAccessReadDevice& d, boost::uint64_t offset,
+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);
 
 /// Start an asynchronous operation to read a certain amount of data at the
 /// specified offset.
 /**
@@ -523,18 +526,20 @@ void async_read_at(AsyncRandomAccessReadDevice& d, boost::uint64_t offset,
  * See the @ref buffer documentation for information on reading into multiple
  * buffers in one go, and how to use it with arrays, boost::array or
  * std::vector.
  */
 template <typename AsyncRandomAccessReadDevice, typename MutableBufferSequence,
     typename CompletionCondition, typename ReadHandler>
-void async_read_at(AsyncRandomAccessReadDevice& d,
-    boost::uint64_t offset, const MutableBufferSequence& buffers,
+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);
 
-#if !defined(BOOST_NO_IOSTREAM)
+#if !defined(BOOST_ASIO_NO_IOSTREAM)
 
 /// Start an asynchronous operation to read a certain amount of data at the
 /// specified offset.
 /**
  * This function is used to asynchronously read a certain number of bytes of
  * data from a random access device at the specified offset. The function call
@@ -577,13 +582,15 @@ void async_read_at(AsyncRandomAccessReadDevice& d,
  *     d, 42, b,
  *     boost::asio::transfer_all(),
  *     handler); @endcode
  */
 template <typename AsyncRandomAccessReadDevice, typename Allocator,
     typename ReadHandler>
-void async_read_at(AsyncRandomAccessReadDevice& d, boost::uint64_t offset,
+BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+    void (boost::system::error_code, std::size_t))
+async_read_at(AsyncRandomAccessReadDevice& d, uint64_t offset,
     basic_streambuf<Allocator>& b, BOOST_ASIO_MOVE_ARG(ReadHandler) handler);
 
 /// Start an asynchronous operation to read a certain amount of data at the
 /// specified offset.
 /**
  * This function is used to asynchronously read a certain number of bytes of
@@ -635,18 +642,20 @@ void async_read_at(AsyncRandomAccessReadDevice& d, boost::uint64_t offset,
  * not, the handler will not be invoked from within this function. Invocation of
  * the handler will be performed in a manner equivalent to using
  * boost::asio::io_service::post().
  */
 template <typename AsyncRandomAccessReadDevice, typename Allocator,
     typename CompletionCondition, typename ReadHandler>
-void async_read_at(AsyncRandomAccessReadDevice& d,
-    boost::uint64_t offset, basic_streambuf<Allocator>& b,
+BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+    void (boost::system::error_code, std::size_t))
+async_read_at(AsyncRandomAccessReadDevice& d,
+    uint64_t offset, basic_streambuf<Allocator>& b,
     CompletionCondition completion_condition,
     BOOST_ASIO_MOVE_ARG(ReadHandler) handler);
 
-#endif // !defined(BOOST_NO_IOSTREAM)
+#endif // !defined(BOOST_ASIO_NO_IOSTREAM)
 
 /*@}*/
 
 } // namespace asio
 } // namespace boost
 
diff --git a/3rdParty/Boost/src/boost/asio/read_until.hpp b/3rdParty/Boost/src/boost/asio/read_until.hpp
index 1f1bddb..a351604 100644
--- a/3rdParty/Boost/src/boost/asio/read_until.hpp
+++ b/3rdParty/Boost/src/boost/asio/read_until.hpp
@@ -1,11 +1,11 @@
 //
 // 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)
 //
 
 #ifndef BOOST_ASIO_READ_UNTIL_HPP
@@ -14,22 +14,20 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
-#if !defined(BOOST_NO_IOSTREAM)
+#if !defined(BOOST_ASIO_NO_IOSTREAM)
 
 #include <cstddef>
-#include <boost/type_traits/is_function.hpp>
-#include <boost/type_traits/remove_pointer.hpp>
-#include <boost/utility/enable_if.hpp>
-#include <boost/detail/workaround.hpp>
 #include <string>
+#include <boost/asio/async_result.hpp>
 #include <boost/asio/basic_streambuf.hpp>
 #include <boost/asio/detail/regex_fwd.hpp>
+#include <boost/asio/detail/type_traits.hpp>
 #include <boost/asio/error.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
@@ -56,13 +54,14 @@ struct is_match_condition
 #if defined(GENERATING_DOCUMENTATION)
   /// The value member is true if the type may be used as a match condition.
   static const bool value;
 #else
   enum
   {
-    value = boost::is_function<typename boost::remove_pointer<T>::type>::value
+    value = boost::asio::is_function<
+        typename boost::asio::remove_pointer<T>::type>::value
       || detail::has_result_type<T>::value
   };
 #endif
 };
 
 /**
@@ -244,12 +243,15 @@ std::size_t read_until(SyncReadStream& s,
  */
 template <typename SyncReadStream, typename Allocator>
 std::size_t read_until(SyncReadStream& s,
     boost::asio::basic_streambuf<Allocator>& b, const std::string& delim,
     boost::system::error_code& ec);
 
+#if defined(BOOST_ASIO_HAS_BOOST_REGEX) \
+  || defined(GENERATING_DOCUMENTATION)
+
 /// Read data into a streambuf until some part of the data it contains matches
 /// a regular expression.
 /**
  * This function is used to read data into the specified streambuf until the
  * streambuf's get area contains some data that matches a regular expression.
  * The call will block until one of the following conditions is true:
@@ -336,12 +338,15 @@ std::size_t read_until(SyncReadStream& s,
  */
 template <typename SyncReadStream, typename Allocator>
 std::size_t read_until(SyncReadStream& s,
     boost::asio::basic_streambuf<Allocator>& b, const boost::regex& expr,
     boost::system::error_code& ec);
 
+#endif // defined(BOOST_ASIO_HAS_BOOST_REGEX)
+       // || defined(GENERATING_DOCUMENTATION)
+
 /// Read data into a streambuf until a function object indicates a match.
 /**
  * This function is used to read data into the specified streambuf until a
  * user-defined match condition function object, when applied to the data
  * contained in the streambuf, indicates a successful match. The call will
  * block until one of the following conditions is true:
@@ -438,13 +443,13 @@ std::size_t read_until(SyncReadStream& s,
  * boost::asio::read_until(s, b, match_char('a'));
  * @endcode
  */
 template <typename SyncReadStream, typename Allocator, typename MatchCondition>
 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* = 0);
+    typename enable_if<is_match_condition<MatchCondition>::value>::type* = 0);
 
 /// Read data into a streambuf until a function object indicates a match.
 /**
  * This function is used to read data into the specified streambuf until a
  * user-defined match condition function object, when applied to the data
  * contained in the streambuf, indicates a successful match. The call will
@@ -494,13 +499,13 @@ std::size_t read_until(SyncReadStream& s,
  * function objects.
  */
 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* = 0);
+    typename enable_if<is_match_condition<MatchCondition>::value>::type* = 0);
 
 /*@}*/
 /**
  * @defgroup async_read_until boost::asio::async_read_until
  *
  * @brief Start an asynchronous operation to read data into a streambuf until it
@@ -585,13 +590,15 @@ std::size_t read_until(SyncReadStream& s,
  * The remaining data is left in the buffer @c b as follows:
  * @code { 'd', 'e', ... } @endcode
  * This data may be the start of a new line, to be extracted by a subsequent
  * @c async_read_until operation.
  */
 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);
 
 /// Start an asynchronous operation to read data into a streambuf until it
 /// contains a specified delimiter.
 /**
@@ -668,16 +675,21 @@ void async_read_until(AsyncReadStream& s,
  * The remaining data is left in the buffer @c b as follows:
  * @code { 'd', 'e', ... } @endcode
  * This data may be the start of a new line, to be extracted by a subsequent
  * @c async_read_until operation.
  */
 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);
 
+#if defined(BOOST_ASIO_HAS_BOOST_REGEX) \
+  || defined(GENERATING_DOCUMENTATION)
+
 /// Start an asynchronous operation to read data into a streambuf until some
 /// part of its data matches a regular expression.
 /**
  * This function is used to asynchronously read data into the specified
  * streambuf until the streambuf's get area contains some data that matches a
  * regular expression. The function call always returns immediately. The
@@ -755,16 +767,21 @@ void async_read_until(AsyncReadStream& s,
  * The remaining data is left in the buffer @c b as follows:
  * @code { 'd', 'e', ... } @endcode
  * This data may be the start of a new line, to be extracted by a subsequent
  * @c async_read_until operation.
  */
 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);
 
+#endif // defined(BOOST_ASIO_HAS_BOOST_REGEX)
+       // || defined(GENERATING_DOCUMENTATION)
+
 /// Start an asynchronous operation to read data into a streambuf until a
 /// function object indicates a match.
 /**
  * This function is used to asynchronously read data into the specified
  * streambuf until a user-defined match condition function object, when applied
  * to the data contained in the streambuf, indicates a successful match. The
@@ -884,23 +901,25 @@ void async_read_until(AsyncReadStream& s,
  * boost::asio::streambuf b;
  * boost::asio::async_read_until(s, b, match_char('a'), handler);
  * @endcode
  */
 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* = 0);
+    typename enable_if<is_match_condition<MatchCondition>::value>::type* = 0);
 
 /*@}*/
 
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #include <boost/asio/impl/read_until.hpp>
 
-#endif // !defined(BOOST_NO_IOSTREAM)
+#endif // !defined(BOOST_ASIO_NO_IOSTREAM)
 
 #endif // BOOST_ASIO_READ_UNTIL_HPP
diff --git a/3rdParty/Boost/src/boost/asio/seq_packet_socket_service.hpp b/3rdParty/Boost/src/boost/asio/seq_packet_socket_service.hpp
index edd1593..10d2fba 100644
--- a/3rdParty/Boost/src/boost/asio/seq_packet_socket_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/seq_packet_socket_service.hpp
@@ -1,11 +1,11 @@
 //
 // seq_packet_socket_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)
 //
 
 #ifndef BOOST_ASIO_SEQ_PACKET_SOCKET_SERVICE_HPP
@@ -14,16 +14,20 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 #include <cstddef>
+#include <boost/asio/async_result.hpp>
+#include <boost/asio/detail/type_traits.hpp>
 #include <boost/asio/error.hpp>
 #include <boost/asio/io_service.hpp>
 
-#if defined(BOOST_ASIO_HAS_IOCP)
+#if defined(BOOST_ASIO_WINDOWS_RUNTIME)
+# include <boost/asio/detail/null_socket_service.hpp>
+#elif defined(BOOST_ASIO_HAS_IOCP)
 # include <boost/asio/detail/win_iocp_socket_service.hpp>
 #else
 # include <boost/asio/detail/reactive_socket_service.hpp>
 #endif
 
 #include <boost/asio/detail/push_options.hpp>
@@ -52,13 +56,15 @@ public:
 
   /// The endpoint type.
   typedef typename Protocol::endpoint endpoint_type;
 
 private:
   // The type of the platform-specific implementation.
-#if defined(BOOST_ASIO_HAS_IOCP)
+#if defined(BOOST_ASIO_WINDOWS_RUNTIME)
+  typedef detail::null_socket_service<Protocol> service_impl_type;
+#elif defined(BOOST_ASIO_HAS_IOCP)
   typedef detail::win_iocp_socket_service<Protocol> service_impl_type;
 #else
   typedef detail::reactive_socket_service<Protocol> service_impl_type;
 #endif
 
 public:
@@ -110,25 +116,38 @@ public:
   void move_assign(implementation_type& impl,
       seq_packet_socket_service& other_service,
       implementation_type& other_impl)
   {
     service_impl_.move_assign(impl, other_service.service_impl_, other_impl);
   }
+
+  /// Move-construct a new sequenced packet socket implementation from another
+  /// protocol type.
+  template <typename Protocol1>
+  void converting_move_construct(implementation_type& impl,
+      typename seq_packet_socket_service<
+        Protocol1>::implementation_type& other_impl,
+      typename enable_if<is_convertible<
+        Protocol1, Protocol>::value>::type* = 0)
+  {
+    service_impl_.template converting_move_construct<Protocol1>(
+        impl, other_impl);
+  }
 #endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
 
   /// Destroy a sequenced packet socket implementation.
   void destroy(implementation_type& impl)
   {
     service_impl_.destroy(impl);
   }
 
   /// Open a sequenced packet socket.
   boost::system::error_code open(implementation_type& impl,
       const protocol_type& protocol, boost::system::error_code& ec)
   {
-    if (protocol.type() == SOCK_SEQPACKET)
+    if (protocol.type() == BOOST_ASIO_OS_DEF(SOCK_SEQPACKET))
       service_impl_.open(impl, protocol, ec);
     else
       ec = boost::asio::error::invalid_argument;
     return ec;
   }
 
@@ -199,18 +218,25 @@ public:
   {
     return service_impl_.connect(impl, peer_endpoint, ec);
   }
 
   /// Start an asynchronous connect.
   template <typename ConnectHandler>
-  void async_connect(implementation_type& impl,
+  BOOST_ASIO_INITFN_RESULT_TYPE(ConnectHandler,
+      void (boost::system::error_code))
+  async_connect(implementation_type& impl,
       const endpoint_type& peer_endpoint,
       BOOST_ASIO_MOVE_ARG(ConnectHandler) handler)
   {
-    service_impl_.async_connect(impl, peer_endpoint,
+    detail::async_result_init<
+      ConnectHandler, void (boost::system::error_code)> init(
         BOOST_ASIO_MOVE_CAST(ConnectHandler)(handler));
+
+    service_impl_.async_connect(impl, peer_endpoint, init.handler);
+
+    return init.result.get();
   }
 
   /// Set a socket option.
   template <typename SettableSocketOption>
   boost::system::error_code set_option(implementation_type& impl,
       const SettableSocketOption& option, boost::system::error_code& ec)
@@ -289,19 +315,26 @@ public:
   {
     return service_impl_.send(impl, buffers, flags, ec);
   }
 
   /// Start an asynchronous send.
   template <typename ConstBufferSequence, typename WriteHandler>
-  void async_send(implementation_type& impl,
+  BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,
+      void (boost::system::error_code, std::size_t))
+  async_send(implementation_type& impl,
       const ConstBufferSequence& buffers,
       socket_base::message_flags flags,
       BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
   {
-    service_impl_.async_send(impl, buffers, flags,
+    detail::async_result_init<
+      WriteHandler, void (boost::system::error_code, std::size_t)> init(
         BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
+
+    service_impl_.async_send(impl, buffers, flags, init.handler);
+
+    return init.result.get();
   }
 
   /// Receive some data from the peer.
   template <typename MutableBufferSequence>
   std::size_t receive(implementation_type& impl,
       const MutableBufferSequence& buffers, socket_base::message_flags in_flags,
@@ -310,19 +343,27 @@ public:
     return service_impl_.receive_with_flags(impl,
         buffers, in_flags, out_flags, ec);
   }
 
   /// Start an asynchronous receive.
   template <typename MutableBufferSequence, typename ReadHandler>
-  void async_receive(implementation_type& impl,
+  BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+      void (boost::system::error_code, std::size_t))
+  async_receive(implementation_type& impl,
       const MutableBufferSequence& buffers, socket_base::message_flags in_flags,
       socket_base::message_flags& out_flags,
       BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
   {
-    service_impl_.async_receive_with_flags(impl, buffers, in_flags,
-        out_flags, BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
+    detail::async_result_init<
+      ReadHandler, void (boost::system::error_code, std::size_t)> init(
+        BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
+
+    service_impl_.async_receive_with_flags(impl,
+        buffers, in_flags, out_flags, init.handler);
+
+    return init.result.get();
   }
 
 private:
   // Destroy all user-defined handler objects owned by the service.
   void shutdown_service()
   {
diff --git a/3rdParty/Boost/src/boost/asio/serial_port.hpp b/3rdParty/Boost/src/boost/asio/serial_port.hpp
index 58d6b78..824e1e2 100644
--- a/3rdParty/Boost/src/boost/asio/serial_port.hpp
+++ b/3rdParty/Boost/src/boost/asio/serial_port.hpp
@@ -1,11 +1,11 @@
 //
 // serial_port.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
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 //
 
diff --git a/3rdParty/Boost/src/boost/asio/serial_port_base.hpp b/3rdParty/Boost/src/boost/asio/serial_port_base.hpp
index f14ba02..d6f6677 100644
--- a/3rdParty/Boost/src/boost/asio/serial_port_base.hpp
+++ b/3rdParty/Boost/src/boost/asio/serial_port_base.hpp
@@ -1,11 +1,11 @@
 //
 // 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
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 //
 
@@ -18,23 +18,22 @@
 
 #include <boost/asio/detail/config.hpp>
 
 #if defined(BOOST_ASIO_HAS_SERIAL_PORT) \
   || defined(GENERATING_DOCUMENTATION)
 
-#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+#if !defined(BOOST_ASIO_WINDOWS) && !defined(__CYGWIN__)
 # include <termios.h>
-#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
+#endif // !defined(BOOST_ASIO_WINDOWS) && !defined(__CYGWIN__)
 
-#include <boost/detail/workaround.hpp>
 #include <boost/asio/detail/socket_types.hpp>
 #include <boost/system/error_code.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
 #endif
 
 #include <boost/asio/detail/push_options.hpp>
@@ -147,18 +146,12 @@ public:
 
 protected:
   /// Protected destructor to prevent deletion through this type.
   ~serial_port_base()
   {
   }
-
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
-private:
-  // Workaround to enable the empty base optimisation with Borland C++.
-  char dummy_;
-#endif
 };
 
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
diff --git a/3rdParty/Boost/src/boost/asio/serial_port_service.hpp b/3rdParty/Boost/src/boost/asio/serial_port_service.hpp
index ed7306c..5b17671 100644
--- a/3rdParty/Boost/src/boost/asio/serial_port_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/serial_port_service.hpp
@@ -1,11 +1,11 @@
 //
 // serial_port_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)
 //
 
 #ifndef BOOST_ASIO_SERIAL_PORT_SERVICE_HPP
@@ -19,12 +19,13 @@
 
 #if defined(BOOST_ASIO_HAS_SERIAL_PORT) \
   || defined(GENERATING_DOCUMENTATION)
 
 #include <cstddef>
 #include <string>
+#include <boost/asio/async_result.hpp>
 #include <boost/asio/detail/reactive_serial_port_service.hpp>
 #include <boost/asio/detail/win_iocp_serial_port_service.hpp>
 #include <boost/asio/error.hpp>
 #include <boost/asio/io_service.hpp>
 #include <boost/asio/serial_port_base.hpp>
 
@@ -189,36 +190,50 @@ public:
   {
     return service_impl_.write_some(impl, buffers, ec);
   }
 
   /// Start an asynchronous write.
   template <typename ConstBufferSequence, typename WriteHandler>
-  void async_write_some(implementation_type& impl,
+  BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,
+      void (boost::system::error_code, std::size_t))
+  async_write_some(implementation_type& impl,
       const ConstBufferSequence& buffers,
       BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
   {
-    service_impl_.async_write_some(impl, buffers,
+    detail::async_result_init<
+      WriteHandler, void (boost::system::error_code, std::size_t)> init(
         BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
+
+    service_impl_.async_write_some(impl, buffers, init.handler);
+
+    return init.result.get();
   }
 
   /// Read some data from the stream.
   template <typename MutableBufferSequence>
   std::size_t read_some(implementation_type& impl,
       const MutableBufferSequence& buffers, boost::system::error_code& ec)
   {
     return service_impl_.read_some(impl, buffers, ec);
   }
 
   /// Start an asynchronous read.
   template <typename MutableBufferSequence, typename ReadHandler>
-  void async_read_some(implementation_type& impl,
+  BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+      void (boost::system::error_code, std::size_t))
+  async_read_some(implementation_type& impl,
       const MutableBufferSequence& buffers,
       BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
   {
-    service_impl_.async_read_some(impl, buffers,
+    detail::async_result_init<
+      ReadHandler, void (boost::system::error_code, std::size_t)> init(
         BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
+
+    service_impl_.async_read_some(impl, buffers, init.handler);
+
+    return init.result.get();
   }
 
 private:
   // Destroy all user-defined handler objects owned by the service.
   void shutdown_service()
   {
diff --git a/3rdParty/Boost/src/boost/asio/signal_set.hpp b/3rdParty/Boost/src/boost/asio/signal_set.hpp
index 3427a03..94fcad8 100644
--- a/3rdParty/Boost/src/boost/asio/signal_set.hpp
+++ b/3rdParty/Boost/src/boost/asio/signal_set.hpp
@@ -1,11 +1,11 @@
 //
 // signal_set.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)
 //
 
 #ifndef BOOST_ASIO_SIGNAL_SET_HPP
diff --git a/3rdParty/Boost/src/boost/asio/signal_set_service.hpp b/3rdParty/Boost/src/boost/asio/signal_set_service.hpp
index 48896f2..029b9af 100644
--- a/3rdParty/Boost/src/boost/asio/signal_set_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/signal_set_service.hpp
@@ -1,11 +1,11 @@
 //
 // signal_set_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)
 //
 
 #ifndef BOOST_ASIO_SIGNAL_SET_SERVICE_HPP
@@ -13,12 +13,13 @@
 
 #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/async_result.hpp>
 #include <boost/asio/detail/signal_set_service.hpp>
 #include <boost/asio/error.hpp>
 #include <boost/asio/io_service.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
@@ -93,17 +94,24 @@ public:
   {
     return service_impl_.cancel(impl, ec);
   }
 
   // Start an asynchronous operation to wait for a signal to be delivered.
   template <typename SignalHandler>
-  void async_wait(implementation_type& impl,
+  BOOST_ASIO_INITFN_RESULT_TYPE(SignalHandler,
+      void (boost::system::error_code, int))
+  async_wait(implementation_type& impl,
       BOOST_ASIO_MOVE_ARG(SignalHandler) handler)
   {
-    service_impl_.async_wait(impl,
+    detail::async_result_init<
+      SignalHandler, void (boost::system::error_code, int)> init(
         BOOST_ASIO_MOVE_CAST(SignalHandler)(handler));
+
+    service_impl_.async_wait(impl, init.handler);
+
+    return init.result.get();
   }
 
 private:
   // Destroy all user-defined handler objects owned by the service.
   void shutdown_service()
   {
diff --git a/3rdParty/Boost/src/boost/asio/socket_acceptor_service.hpp b/3rdParty/Boost/src/boost/asio/socket_acceptor_service.hpp
index 54aaf7a..9a1963c 100644
--- a/3rdParty/Boost/src/boost/asio/socket_acceptor_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/socket_acceptor_service.hpp
@@ -1,11 +1,11 @@
 //
 // socket_acceptor_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)
 //
 
 #ifndef BOOST_ASIO_SOCKET_ACCEPTOR_SERVICE_HPP
@@ -14,16 +14,19 @@
 #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/basic_socket.hpp>
+#include <boost/asio/detail/type_traits.hpp>
 #include <boost/asio/error.hpp>
 #include <boost/asio/io_service.hpp>
 
-#if defined(BOOST_ASIO_HAS_IOCP)
+#if defined(BOOST_ASIO_WINDOWS_RUNTIME)
+# include <boost/asio/detail/null_socket_service.hpp>
+#elif defined(BOOST_ASIO_HAS_IOCP)
 # include <boost/asio/detail/win_iocp_socket_service.hpp>
 #else
 # include <boost/asio/detail/reactive_socket_service.hpp>
 #endif
 
 #include <boost/asio/detail/push_options.hpp>
@@ -51,13 +54,15 @@ public:
 
   /// The endpoint type.
   typedef typename protocol_type::endpoint endpoint_type;
 
 private:
   // The type of the platform-specific implementation.
-#if defined(BOOST_ASIO_HAS_IOCP)
+#if defined(BOOST_ASIO_WINDOWS_RUNTIME)
+  typedef detail::null_socket_service<Protocol> service_impl_type;
+#elif defined(BOOST_ASIO_HAS_IOCP)
   typedef detail::win_iocp_socket_service<Protocol> service_impl_type;
 #else
   typedef detail::reactive_socket_service<Protocol> service_impl_type;
 #endif
 
 public:
@@ -108,12 +113,25 @@ public:
   void move_assign(implementation_type& impl,
       socket_acceptor_service& other_service,
       implementation_type& other_impl)
   {
     service_impl_.move_assign(impl, other_service.service_impl_, other_impl);
   }
+
+  /// Move-construct a new socket acceptor implementation from another protocol
+  /// type.
+  template <typename Protocol1>
+  void converting_move_construct(implementation_type& impl,
+      typename socket_acceptor_service<
+        Protocol1>::implementation_type& other_impl,
+      typename enable_if<is_convertible<
+        Protocol1, Protocol>::value>::type* = 0)
+  {
+    service_impl_.template converting_move_construct<Protocol1>(
+        impl, other_impl);
+  }
 #endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
 
   /// Destroy a socket acceptor implementation.
   void destroy(implementation_type& impl)
   {
     service_impl_.destroy(impl);
@@ -236,29 +254,38 @@ public:
       boost::system::error_code& ec) const
   {
     return service_impl_.local_endpoint(impl, ec);
   }
 
   /// Accept a new connection.
-  template <typename SocketService>
+  template <typename Protocol1, typename SocketService>
   boost::system::error_code accept(implementation_type& impl,
-      basic_socket<protocol_type, SocketService>& peer,
-      endpoint_type* peer_endpoint, boost::system::error_code& ec)
+      basic_socket<Protocol1, SocketService>& peer,
+      endpoint_type* peer_endpoint, boost::system::error_code& ec,
+      typename enable_if<is_convertible<Protocol, Protocol1>::value>::type* = 0)
   {
     return service_impl_.accept(impl, peer, peer_endpoint, ec);
   }
 
   /// Start an asynchronous accept.
-  template <typename SocketService, typename AcceptHandler>
-  void async_accept(implementation_type& impl,
-      basic_socket<protocol_type, SocketService>& peer,
+  template <typename Protocol1, typename SocketService, typename AcceptHandler>
+  BOOST_ASIO_INITFN_RESULT_TYPE(AcceptHandler,
+      void (boost::system::error_code))
+  async_accept(implementation_type& impl,
+      basic_socket<Protocol1, SocketService>& peer,
       endpoint_type* peer_endpoint,
-      BOOST_ASIO_MOVE_ARG(AcceptHandler) handler)
+      BOOST_ASIO_MOVE_ARG(AcceptHandler) handler,
+      typename enable_if<is_convertible<Protocol, Protocol1>::value>::type* = 0)
   {
-    service_impl_.async_accept(impl, peer, peer_endpoint,
+    detail::async_result_init<
+      AcceptHandler, void (boost::system::error_code)> init(
         BOOST_ASIO_MOVE_CAST(AcceptHandler)(handler));
+
+    service_impl_.async_accept(impl, peer, peer_endpoint, init.handler);
+
+    return init.result.get();
   }
 
 private:
   // Destroy all user-defined handler objects owned by the service.
   void shutdown_service()
   {
diff --git a/3rdParty/Boost/src/boost/asio/socket_base.hpp b/3rdParty/Boost/src/boost/asio/socket_base.hpp
index f964d00..e034d67 100644
--- a/3rdParty/Boost/src/boost/asio/socket_base.hpp
+++ b/3rdParty/Boost/src/boost/asio/socket_base.hpp
@@ -1,11 +1,11 @@
 //
 // socket_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)
 //
 // 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_SOCKET_BASE_HPP
@@ -13,13 +13,12 @@
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
-#include <boost/detail/workaround.hpp>
 #include <boost/asio/detail/io_control.hpp>
 #include <boost/asio/detail/socket_option.hpp>
 #include <boost/asio/detail/socket_types.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
@@ -42,15 +41,15 @@ public:
     /// Shutdown the send side of the socket.
     shutdown_send = implementation_defined,
 
     /// Shutdown both send and receive on the socket.
     shutdown_both = implementation_defined
 #else
-    shutdown_receive = boost::asio::detail::shutdown_receive,
-    shutdown_send = boost::asio::detail::shutdown_send,
-    shutdown_both = boost::asio::detail::shutdown_both
+    shutdown_receive = BOOST_ASIO_OS_DEF(SHUT_RD),
+    shutdown_send = BOOST_ASIO_OS_DEF(SHUT_WR),
+    shutdown_both = BOOST_ASIO_OS_DEF(SHUT_RDWR)
 #endif
   };
 
   /// Bitmask type for flags that can be passed to send and receive operations.
   typedef int message_flags;
 
@@ -64,20 +63,20 @@ public:
   /// Specify that the data should not be subject to routing.
   static const int message_do_not_route = implementation_defined;
 
   /// Specifies that the data marks the end of a record.
   static const int message_end_of_record = implementation_defined;
 #else
-  BOOST_STATIC_CONSTANT(int,
-      message_peek = boost::asio::detail::message_peek);
-  BOOST_STATIC_CONSTANT(int,
-      message_out_of_band = boost::asio::detail::message_out_of_band);
-  BOOST_STATIC_CONSTANT(int,
-      message_do_not_route = boost::asio::detail::message_do_not_route);
-  BOOST_STATIC_CONSTANT(int,
-      message_end_of_record = boost::asio::detail::message_end_of_record);
+  BOOST_ASIO_STATIC_CONSTANT(int,
+      message_peek = BOOST_ASIO_OS_DEF(MSG_PEEK));
+  BOOST_ASIO_STATIC_CONSTANT(int,
+      message_out_of_band = BOOST_ASIO_OS_DEF(MSG_OOB));
+  BOOST_ASIO_STATIC_CONSTANT(int,
+      message_do_not_route = BOOST_ASIO_OS_DEF(MSG_DONTROUTE));
+  BOOST_ASIO_STATIC_CONSTANT(int,
+      message_end_of_record = BOOST_ASIO_OS_DEF(MSG_EOR));
 #endif
 
   /// Socket option to permit sending of broadcast messages.
   /**
    * Implements the SOL_SOCKET/SO_BROADCAST socket option.
    *
@@ -104,13 +103,14 @@ public:
    * Socket_Option, Boolean_Socket_Option.
    */
 #if defined(GENERATING_DOCUMENTATION)
   typedef implementation_defined broadcast;
 #else
   typedef boost::asio::detail::socket_option::boolean<
-    SOL_SOCKET, SO_BROADCAST> broadcast;
+    BOOST_ASIO_OS_DEF(SOL_SOCKET), BOOST_ASIO_OS_DEF(SO_BROADCAST)>
+      broadcast;
 #endif
 
   /// Socket option to enable socket-level debugging.
   /**
    * Implements the SOL_SOCKET/SO_DEBUG socket option.
    *
@@ -137,13 +137,13 @@ public:
    * Socket_Option, Boolean_Socket_Option.
    */
 #if defined(GENERATING_DOCUMENTATION)
   typedef implementation_defined debug;
 #else
   typedef boost::asio::detail::socket_option::boolean<
-    SOL_SOCKET, SO_DEBUG> debug;
+    BOOST_ASIO_OS_DEF(SOL_SOCKET), BOOST_ASIO_OS_DEF(SO_DEBUG)> debug;
 #endif
 
   /// Socket option to prevent routing, use local interfaces only.
   /**
    * Implements the SOL_SOCKET/SO_DONTROUTE socket option.
    *
@@ -170,13 +170,14 @@ public:
    * Socket_Option, Boolean_Socket_Option.
    */
 #if defined(GENERATING_DOCUMENTATION)
   typedef implementation_defined do_not_route;
 #else
   typedef boost::asio::detail::socket_option::boolean<
-    SOL_SOCKET, SO_DONTROUTE> do_not_route;
+    BOOST_ASIO_OS_DEF(SOL_SOCKET), BOOST_ASIO_OS_DEF(SO_DONTROUTE)>
+      do_not_route;
 #endif
 
   /// Socket option to send keep-alives.
   /**
    * Implements the SOL_SOCKET/SO_KEEPALIVE socket option.
    *
@@ -203,13 +204,13 @@ public:
    * Socket_Option, Boolean_Socket_Option.
    */
 #if defined(GENERATING_DOCUMENTATION)
   typedef implementation_defined keep_alive;
 #else
   typedef boost::asio::detail::socket_option::boolean<
-    SOL_SOCKET, SO_KEEPALIVE> keep_alive;
+    BOOST_ASIO_OS_DEF(SOL_SOCKET), BOOST_ASIO_OS_DEF(SO_KEEPALIVE)> keep_alive;
 #endif
 
   /// Socket option for the send buffer size of a socket.
   /**
    * Implements the SOL_SOCKET/SO_SNDBUF socket option.
    *
@@ -236,13 +237,14 @@ public:
    * Socket_Option, Integer_Socket_Option.
    */
 #if defined(GENERATING_DOCUMENTATION)
   typedef implementation_defined send_buffer_size;
 #else
   typedef boost::asio::detail::socket_option::integer<
-    SOL_SOCKET, SO_SNDBUF> send_buffer_size;
+    BOOST_ASIO_OS_DEF(SOL_SOCKET), BOOST_ASIO_OS_DEF(SO_SNDBUF)>
+      send_buffer_size;
 #endif
 
   /// Socket option for the send low watermark.
   /**
    * Implements the SOL_SOCKET/SO_SNDLOWAT socket option.
    *
@@ -269,13 +271,14 @@ public:
    * Socket_Option, Integer_Socket_Option.
    */
 #if defined(GENERATING_DOCUMENTATION)
   typedef implementation_defined send_low_watermark;
 #else
   typedef boost::asio::detail::socket_option::integer<
-    SOL_SOCKET, SO_SNDLOWAT> send_low_watermark;
+    BOOST_ASIO_OS_DEF(SOL_SOCKET), BOOST_ASIO_OS_DEF(SO_SNDLOWAT)>
+      send_low_watermark;
 #endif
 
   /// Socket option for the receive buffer size of a socket.
   /**
    * Implements the SOL_SOCKET/SO_RCVBUF socket option.
    *
@@ -302,13 +305,14 @@ public:
    * Socket_Option, Integer_Socket_Option.
    */
 #if defined(GENERATING_DOCUMENTATION)
   typedef implementation_defined receive_buffer_size;
 #else
   typedef boost::asio::detail::socket_option::integer<
-    SOL_SOCKET, SO_RCVBUF> receive_buffer_size;
+    BOOST_ASIO_OS_DEF(SOL_SOCKET), BOOST_ASIO_OS_DEF(SO_RCVBUF)>
+      receive_buffer_size;
 #endif
 
   /// Socket option for the receive low watermark.
   /**
    * Implements the SOL_SOCKET/SO_RCVLOWAT socket option.
    *
@@ -335,13 +339,14 @@ public:
    * Socket_Option, Integer_Socket_Option.
    */
 #if defined(GENERATING_DOCUMENTATION)
   typedef implementation_defined receive_low_watermark;
 #else
   typedef boost::asio::detail::socket_option::integer<
-    SOL_SOCKET, SO_RCVLOWAT> receive_low_watermark;
+    BOOST_ASIO_OS_DEF(SOL_SOCKET), BOOST_ASIO_OS_DEF(SO_RCVLOWAT)>
+      receive_low_watermark;
 #endif
 
   /// Socket option to allow the socket to be bound to an address that is
   /// already in use.
   /**
    * Implements the SOL_SOCKET/SO_REUSEADDR socket option.
@@ -369,13 +374,14 @@ public:
    * Socket_Option, Boolean_Socket_Option.
    */
 #if defined(GENERATING_DOCUMENTATION)
   typedef implementation_defined reuse_address;
 #else
   typedef boost::asio::detail::socket_option::boolean<
-    SOL_SOCKET, SO_REUSEADDR> reuse_address;
+    BOOST_ASIO_OS_DEF(SOL_SOCKET), BOOST_ASIO_OS_DEF(SO_REUSEADDR)>
+      reuse_address;
 #endif
 
   /// Socket option to specify whether the socket lingers on close if unsent
   /// data is present.
   /**
    * Implements the SOL_SOCKET/SO_LINGER socket option.
@@ -404,13 +410,14 @@ public:
    * Socket_Option, Linger_Socket_Option.
    */
 #if defined(GENERATING_DOCUMENTATION)
   typedef implementation_defined linger;
 #else
   typedef boost::asio::detail::socket_option::linger<
-    SOL_SOCKET, SO_LINGER> linger;
+    BOOST_ASIO_OS_DEF(SOL_SOCKET), BOOST_ASIO_OS_DEF(SO_LINGER)>
+      linger;
 #endif
 
   /// Socket option to report aborted connections on accept.
   /**
    * Implements a custom socket option that determines whether or not an accept
    * operation is permitted to fail with boost::asio::error::connection_aborted.
@@ -493,26 +500,21 @@ public:
 #endif
 
   /// The maximum length of the queue of pending incoming connections.
 #if defined(GENERATING_DOCUMENTATION)
   static const int max_connections = implementation_defined;
 #else
-  BOOST_STATIC_CONSTANT(int, max_connections = SOMAXCONN);
+  BOOST_ASIO_STATIC_CONSTANT(int, max_connections
+      = BOOST_ASIO_OS_DEF(SOMAXCONN));
 #endif
 
 protected:
   /// Protected destructor to prevent deletion through this type.
   ~socket_base()
   {
   }
-
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
-private:
-  // Workaround to enable the empty base optimisation with Borland C++.
-  char dummy_;
-#endif
 };
 
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
diff --git a/3rdParty/Boost/src/boost/asio/steady_timer.hpp b/3rdParty/Boost/src/boost/asio/steady_timer.hpp
new file mode 100644
index 0000000..fd32529
--- /dev/null
+++ b/3rdParty/Boost/src/boost/asio/steady_timer.hpp
@@ -0,0 +1,63 @@
+//
+// steady_timer.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_STEADY_TIMER_HPP
+#define BOOST_ASIO_STEADY_TIMER_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HAS_STD_CHRONO) \
+  || defined(BOOST_ASIO_HAS_BOOST_CHRONO) \
+  || defined(GENERATING_DOCUMENTATION)
+
+#if defined(BOOST_ASIO_HAS_STD_CHRONO)
+# include <chrono>
+#elif defined(BOOST_ASIO_HAS_BOOST_CHRONO)
+# include <boost/chrono/system_clocks.hpp>
+#endif
+
+#include <boost/asio/basic_waitable_timer.hpp>
+
+namespace boost {
+namespace asio {
+
+#if defined(GENERATING_DOCUMENTATION)
+/// Typedef for a timer based on the steady clock.
+/**
+ * This typedef uses the C++11 @c &lt;chrono&gt; standard library facility, if
+ * available. Otherwise, it may use the Boost.Chrono library. To explicitly
+ * utilise Boost.Chrono, use the basic_waitable_timer template directly:
+ * @code
+ * typedef basic_waitable_timer<boost::chrono::steady_clock> timer;
+ * @endcode
+ */
+typedef basic_waitable_timer<chrono::steady_clock> steady_timer;
+#elif defined(BOOST_ASIO_HAS_STD_CHRONO)
+# if defined(BOOST_ASIO_HAS_STD_CHRONO_MONOTONIC_CLOCK)
+typedef basic_waitable_timer<std::chrono::monotonic_clock> steady_timer;
+# else // defined(BOOST_ASIO_HAS_STD_CHRONO_MONOTONIC_CLOCK)
+typedef basic_waitable_timer<std::chrono::steady_clock> steady_timer;
+# endif // defined(BOOST_ASIO_HAS_STD_CHRONO_MONOTONIC_CLOCK)
+#elif defined(BOOST_ASIO_HAS_BOOST_CHRONO)
+typedef basic_waitable_timer<boost::chrono::steady_clock> steady_timer;
+#endif
+
+} // namespace asio
+} // namespace boost
+
+#endif // defined(BOOST_ASIO_HAS_STD_CHRONO) 
+       //   || defined(BOOST_ASIO_HAS_BOOST_CHRONO)
+       //   || defined(GENERATING_DOCUMENTATION)
+
+#endif // BOOST_ASIO_STEADY_TIMER_HPP
diff --git a/3rdParty/Boost/src/boost/asio/strand.hpp b/3rdParty/Boost/src/boost/asio/strand.hpp
index 6a1033f..f6b62fb 100644
--- a/3rdParty/Boost/src/boost/asio/strand.hpp
+++ b/3rdParty/Boost/src/boost/asio/strand.hpp
@@ -1,11 +1,11 @@
 //
 // strand.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)
 //
 
 #ifndef BOOST_ASIO_STRAND_HPP
@@ -13,12 +13,13 @@
 
 #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/async_result.hpp>
 #include <boost/asio/detail/handler_type_requirements.hpp>
 #include <boost/asio/detail/strand_service.hpp>
 #include <boost/asio/detail/wrapped_handler.hpp>
 #include <boost/asio/io_service.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
@@ -69,12 +70,15 @@ namespace asio {
  * the completion of the first async operation will perform @c s.dispatch(a),
  * and the second will perform @c s.dispatch(b), but the order in which those
  * are performed is unspecified. That is, you cannot state whether one
  * happens-before the other. Therefore none of the above conditions are met and
  * no ordering guarantee is made.
  *
+ * @note The implementation makes no guarantee that handlers posted or
+ * dispatched through different @c strand objects will be invoked concurrently.
+ *
  * @par Thread Safety
  * @e Distinct @e objects: Safe.@n
  * @e Shared @e objects: Safe.
  *
  * @par Concepts:
  * Dispatcher.
@@ -137,19 +141,26 @@ public:
    *
    * @param handler The handler to be called. The strand will make a copy of the
    * handler object as required. The function signature of the handler must be:
    * @code void handler(); @endcode
    */
   template <typename CompletionHandler>
-  void dispatch(BOOST_ASIO_MOVE_ARG(CompletionHandler) handler)
+  BOOST_ASIO_INITFN_RESULT_TYPE(CompletionHandler, void ())
+  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;
 
-    service_.dispatch(impl_, BOOST_ASIO_MOVE_CAST(CompletionHandler)(handler));
+    detail::async_result_init<
+      CompletionHandler, void ()> init(
+        BOOST_ASIO_MOVE_CAST(CompletionHandler)(handler));
+
+    service_.dispatch(impl_, init.handler);
+
+    return init.result.get();
   }
 
   /// Request the strand to invoke the given handler and return
   /// immediately.
   /**
    * This function is used to ask the strand to execute the given handler, but
@@ -163,19 +174,26 @@ public:
    *
    * @param handler The handler to be called. The strand will make a copy of the
    * handler object as required. The function signature of the handler must be:
    * @code void handler(); @endcode
    */
   template <typename CompletionHandler>
-  void post(BOOST_ASIO_MOVE_ARG(CompletionHandler) handler)
+  BOOST_ASIO_INITFN_RESULT_TYPE(CompletionHandler, void ())
+  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;
 
-    service_.post(impl_, BOOST_ASIO_MOVE_CAST(CompletionHandler)(handler));
+    detail::async_result_init<
+      CompletionHandler, void ()> init(
+        BOOST_ASIO_MOVE_CAST(CompletionHandler)(handler));
+
+    service_.post(impl_, init.handler);
+
+    return init.result.get();
   }
 
   /// Create a new handler that automatically dispatches the wrapped handler
   /// on the strand.
   /**
    * This function is used to create a new handler function object that, when
@@ -197,17 +215,29 @@ public:
    * @code strand.dispatch(boost::bind(f, a1, ... an)); @endcode
    */
   template <typename Handler>
 #if defined(GENERATING_DOCUMENTATION)
   unspecified
 #else
-  detail::wrapped_handler<strand, Handler>
+  detail::wrapped_handler<strand, Handler, detail::is_continuation_if_running>
 #endif
   wrap(Handler handler)
   {
-    return detail::wrapped_handler<io_service::strand, Handler>(*this, handler);
+    return detail::wrapped_handler<io_service::strand, Handler,
+        detail::is_continuation_if_running>(*this, handler);
+  }
+
+  /// Determine whether the strand is running in the current thread.
+  /**
+   * @return @c true if the current thread is executing a handler that was
+   * submitted to the strand using post(), dispatch() or wrap(). Otherwise
+   * returns @c false.
+   */
+  bool running_in_this_thread() const
+  {
+    return service_.running_in_this_thread(impl_);
   }
 
 private:
   boost::asio::detail::strand_service& service_;
   boost::asio::detail::strand_service::implementation_type impl_;
 };
diff --git a/3rdParty/Boost/src/boost/asio/stream_socket_service.hpp b/3rdParty/Boost/src/boost/asio/stream_socket_service.hpp
index afc9406..f484d7d 100644
--- a/3rdParty/Boost/src/boost/asio/stream_socket_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/stream_socket_service.hpp
@@ -1,11 +1,11 @@
 //
 // stream_socket_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)
 //
 
 #ifndef BOOST_ASIO_STREAM_SOCKET_SERVICE_HPP
@@ -14,16 +14,20 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 #include <cstddef>
+#include <boost/asio/async_result.hpp>
+#include <boost/asio/detail/type_traits.hpp>
 #include <boost/asio/error.hpp>
 #include <boost/asio/io_service.hpp>
 
-#if defined(BOOST_ASIO_HAS_IOCP)
+#if defined(BOOST_ASIO_WINDOWS_RUNTIME)
+# include <boost/asio/detail/winrt_ssocket_service.hpp>
+#elif defined(BOOST_ASIO_HAS_IOCP)
 # include <boost/asio/detail/win_iocp_socket_service.hpp>
 #else
 # include <boost/asio/detail/reactive_socket_service.hpp>
 #endif
 
 #include <boost/asio/detail/push_options.hpp>
@@ -51,13 +55,15 @@ public:
 
   /// The endpoint type.
   typedef typename Protocol::endpoint endpoint_type;
 
 private:
   // The type of the platform-specific implementation.
-#if defined(BOOST_ASIO_HAS_IOCP)
+#if defined(BOOST_ASIO_WINDOWS_RUNTIME)
+  typedef detail::winrt_ssocket_service<Protocol> service_impl_type;
+#elif defined(BOOST_ASIO_HAS_IOCP)
   typedef detail::win_iocp_socket_service<Protocol> service_impl_type;
 #else
   typedef detail::reactive_socket_service<Protocol> service_impl_type;
 #endif
 
 public:
@@ -108,25 +114,38 @@ public:
   void move_assign(implementation_type& impl,
       stream_socket_service& other_service,
       implementation_type& other_impl)
   {
     service_impl_.move_assign(impl, other_service.service_impl_, other_impl);
   }
+
+  /// Move-construct a new stream socket implementation from another protocol
+  /// type.
+  template <typename Protocol1>
+  void converting_move_construct(implementation_type& impl,
+      typename stream_socket_service<
+        Protocol1>::implementation_type& other_impl,
+      typename enable_if<is_convertible<
+        Protocol1, Protocol>::value>::type* = 0)
+  {
+    service_impl_.template converting_move_construct<Protocol1>(
+        impl, other_impl);
+  }
 #endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
 
   /// Destroy a stream socket implementation.
   void destroy(implementation_type& impl)
   {
     service_impl_.destroy(impl);
   }
 
   /// Open a stream socket.
   boost::system::error_code open(implementation_type& impl,
       const protocol_type& protocol, boost::system::error_code& ec)
   {
-    if (protocol.type() == SOCK_STREAM)
+    if (protocol.type() == BOOST_ASIO_OS_DEF(SOCK_STREAM))
       service_impl_.open(impl, protocol, ec);
     else
       ec = boost::asio::error::invalid_argument;
     return ec;
   }
 
@@ -197,18 +216,25 @@ public:
   {
     return service_impl_.connect(impl, peer_endpoint, ec);
   }
 
   /// Start an asynchronous connect.
   template <typename ConnectHandler>
-  void async_connect(implementation_type& impl,
+  BOOST_ASIO_INITFN_RESULT_TYPE(ConnectHandler,
+      void (boost::system::error_code))
+  async_connect(implementation_type& impl,
       const endpoint_type& peer_endpoint,
       BOOST_ASIO_MOVE_ARG(ConnectHandler) handler)
   {
-    service_impl_.async_connect(impl, peer_endpoint,
+    detail::async_result_init<
+      ConnectHandler, void (boost::system::error_code)> init(
         BOOST_ASIO_MOVE_CAST(ConnectHandler)(handler));
+
+    service_impl_.async_connect(impl, peer_endpoint, init.handler);
+
+    return init.result.get();
   }
 
   /// Set a socket option.
   template <typename SettableSocketOption>
   boost::system::error_code set_option(implementation_type& impl,
       const SettableSocketOption& option, boost::system::error_code& ec)
@@ -287,19 +313,26 @@ public:
   {
     return service_impl_.send(impl, buffers, flags, ec);
   }
 
   /// Start an asynchronous send.
   template <typename ConstBufferSequence, typename WriteHandler>
-  void async_send(implementation_type& impl,
+  BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,
+      void (boost::system::error_code, std::size_t))
+  async_send(implementation_type& impl,
       const ConstBufferSequence& buffers,
       socket_base::message_flags flags,
       BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
   {
-    service_impl_.async_send(impl, buffers, flags,
+    detail::async_result_init<
+      WriteHandler, void (boost::system::error_code, std::size_t)> init(
         BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
+
+    service_impl_.async_send(impl, buffers, flags, init.handler);
+
+    return init.result.get();
   }
 
   /// Receive some data from the peer.
   template <typename MutableBufferSequence>
   std::size_t receive(implementation_type& impl,
       const MutableBufferSequence& buffers,
@@ -307,19 +340,26 @@ public:
   {
     return service_impl_.receive(impl, buffers, flags, ec);
   }
 
   /// Start an asynchronous receive.
   template <typename MutableBufferSequence, typename ReadHandler>
-  void async_receive(implementation_type& impl,
+  BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+      void (boost::system::error_code, std::size_t))
+  async_receive(implementation_type& impl,
       const MutableBufferSequence& buffers,
       socket_base::message_flags flags,
       BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
   {
-    service_impl_.async_receive(impl, buffers, flags,
+    detail::async_result_init<
+      ReadHandler, void (boost::system::error_code, std::size_t)> init(
         BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
+
+    service_impl_.async_receive(impl, buffers, flags, init.handler);
+
+    return init.result.get();
   }
 
 private:
   // Destroy all user-defined handler objects owned by the service.
   void shutdown_service()
   {
diff --git a/3rdParty/Boost/src/boost/asio/streambuf.hpp b/3rdParty/Boost/src/boost/asio/streambuf.hpp
index 004de8d..7dbbb49 100644
--- a/3rdParty/Boost/src/boost/asio/streambuf.hpp
+++ b/3rdParty/Boost/src/boost/asio/streambuf.hpp
@@ -1,11 +1,11 @@
 //
 // streambuf.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)
 //
 
 #ifndef BOOST_ASIO_STREAMBUF_HPP
@@ -14,22 +14,22 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 
-#if !defined(BOOST_NO_IOSTREAM)
+#if !defined(BOOST_ASIO_NO_IOSTREAM)
 
 #include <boost/asio/basic_streambuf.hpp>
 
 namespace boost {
 namespace asio {
 
 /// Typedef for the typical usage of basic_streambuf.
 typedef basic_streambuf<> streambuf;
 
 } // namespace asio
 } // namespace boost
 
-#endif // !defined(BOOST_NO_IOSTREAM)
+#endif // !defined(BOOST_ASIO_NO_IOSTREAM)
 
 #endif // BOOST_ASIO_STREAMBUF_HPP
diff --git a/3rdParty/Boost/src/boost/asio/time_traits.hpp b/3rdParty/Boost/src/boost/asio/time_traits.hpp
index 8f48d47..a5605c1 100644
--- a/3rdParty/Boost/src/boost/asio/time_traits.hpp
+++ b/3rdParty/Boost/src/boost/asio/time_traits.hpp
@@ -1,11 +1,11 @@
 //
 // time_traits.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)
 //
 
 #ifndef BOOST_ASIO_TIME_TRAITS_HPP
@@ -14,12 +14,15 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/socket_types.hpp> // Must come before posix_time.
 
+#if defined(BOOST_ASIO_HAS_BOOST_DATE_TIME) \
+  || defined(GENERATING_DOCUMENTATION)
+
 #include <boost/asio/detail/push_options.hpp>
 #include <boost/date_time/posix_time/posix_time_types.hpp>
 #include <boost/asio/detail/pop_options.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
@@ -78,7 +81,10 @@ struct time_traits<boost::posix_time::ptime>
 
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
+#endif // defined(BOOST_ASIO_HAS_BOOST_DATE_TIME)
+       // || defined(GENERATING_DOCUMENTATION)
+
 #endif // BOOST_ASIO_TIME_TRAITS_HPP
diff --git a/3rdParty/Boost/src/boost/asio/version.hpp b/3rdParty/Boost/src/boost/asio/version.hpp
index 4fc894b..deeab10 100644
--- a/3rdParty/Boost/src/boost/asio/version.hpp
+++ b/3rdParty/Boost/src/boost/asio/version.hpp
@@ -1,11 +1,11 @@
 //
 // version.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)
 //
 
 #ifndef BOOST_ASIO_VERSION_HPP
@@ -15,9 +15,9 @@
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 // BOOST_ASIO_VERSION % 100 is the sub-minor version
 // BOOST_ASIO_VERSION / 100 % 1000 is the minor version
 // BOOST_ASIO_VERSION / 100000 is the major version
-#define BOOST_ASIO_VERSION 100802 // 1.8.2
+#define BOOST_ASIO_VERSION 101004 // 1.10.4
 
 #endif // BOOST_ASIO_VERSION_HPP
diff --git a/3rdParty/Boost/src/boost/asio/wait_traits.hpp b/3rdParty/Boost/src/boost/asio/wait_traits.hpp
index c4eef20..e875e5c 100644
--- a/3rdParty/Boost/src/boost/asio/wait_traits.hpp
+++ b/3rdParty/Boost/src/boost/asio/wait_traits.hpp
@@ -1,11 +1,11 @@
 //
 // wait_traits.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)
 //
 
 #ifndef BOOST_ASIO_WAIT_TRAITS_HPP
diff --git a/3rdParty/Boost/src/boost/asio/waitable_timer_service.hpp b/3rdParty/Boost/src/boost/asio/waitable_timer_service.hpp
index 69a9580..0832bf1 100644
--- a/3rdParty/Boost/src/boost/asio/waitable_timer_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/waitable_timer_service.hpp
@@ -1,11 +1,11 @@
 //
 // waitable_timer_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)
 //
 
 #ifndef BOOST_ASIO_WAITABLE_TIMER_SERVICE_HPP
@@ -14,12 +14,13 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 #include <cstddef>
+#include <boost/asio/async_result.hpp>
 #include <boost/asio/detail/chrono_time_traits.hpp>
 #include <boost/asio/detail/deadline_timer_service.hpp>
 #include <boost/asio/io_service.hpp>
 #include <boost/asio/wait_traits.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
@@ -133,16 +134,24 @@ public:
   {
     service_impl_.wait(impl, ec);
   }
 
   // Start an asynchronous wait on the timer.
   template <typename WaitHandler>
-  void async_wait(implementation_type& impl,
+  BOOST_ASIO_INITFN_RESULT_TYPE(WaitHandler,
+      void (boost::system::error_code))
+  async_wait(implementation_type& impl,
       BOOST_ASIO_MOVE_ARG(WaitHandler) handler)
   {
-    service_impl_.async_wait(impl, BOOST_ASIO_MOVE_CAST(WaitHandler)(handler));
+    detail::async_result_init<
+      WaitHandler, void (boost::system::error_code)> init(
+        BOOST_ASIO_MOVE_CAST(WaitHandler)(handler));
+
+    service_impl_.async_wait(impl, init.handler);
+
+    return init.result.get();
   }
 
 private:
   // Destroy all user-defined handler objects owned by the service.
   void shutdown_service()
   {
diff --git a/3rdParty/Boost/src/boost/asio/windows/basic_handle.hpp b/3rdParty/Boost/src/boost/asio/windows/basic_handle.hpp
index 5169cae..924945c 100644
--- a/3rdParty/Boost/src/boost/asio/windows/basic_handle.hpp
+++ b/3rdParty/Boost/src/boost/asio/windows/basic_handle.hpp
@@ -1,11 +1,11 @@
 //
 // windows/basic_handle.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)
 //
 
 #ifndef BOOST_ASIO_WINDOWS_BASIC_HANDLE_HPP
diff --git a/3rdParty/Boost/src/boost/asio/windows/basic_object_handle.hpp b/3rdParty/Boost/src/boost/asio/windows/basic_object_handle.hpp
index a94bb57..effa74a 100644
--- a/3rdParty/Boost/src/boost/asio/windows/basic_object_handle.hpp
+++ b/3rdParty/Boost/src/boost/asio/windows/basic_object_handle.hpp
@@ -1,11 +1,11 @@
 //
 // windows/basic_object_handle.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) 2011 Boris Schaeling (boris@highscore.de)
 //
 // 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)
 //
 
@@ -156,15 +156,18 @@ public:
    * Regardless of whether the asynchronous operation completes immediately or
    * not, the handler will not be invoked from within this function. Invocation
    * of the handler will be performed in a manner equivalent to using
    * boost::asio::io_service::post().
    */
   template <typename WaitHandler>
-  void async_wait(WaitHandler handler)
+  BOOST_ASIO_INITFN_RESULT_TYPE(WaitHandler,
+      void (boost::system::error_code))
+  async_wait(BOOST_ASIO_MOVE_ARG(WaitHandler) handler)
   {
-    this->get_service().async_wait(this->get_implementation(), handler);
+    return this->get_service().async_wait(this->get_implementation(),
+        BOOST_ASIO_MOVE_CAST(WaitHandler)(handler));
   }
 };
 
 } // namespace windows
 } // namespace asio
 } // namespace boost
diff --git a/3rdParty/Boost/src/boost/asio/windows/basic_random_access_handle.hpp b/3rdParty/Boost/src/boost/asio/windows/basic_random_access_handle.hpp
index 0d57141..22e4390 100644
--- a/3rdParty/Boost/src/boost/asio/windows/basic_random_access_handle.hpp
+++ b/3rdParty/Boost/src/boost/asio/windows/basic_random_access_handle.hpp
@@ -1,11 +1,11 @@
 //
 // windows/basic_random_access_handle.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)
 //
 
 #ifndef BOOST_ASIO_WINDOWS_BASIC_RANDOM_ACCESS_HANDLE_HPP
@@ -55,13 +55,13 @@ public:
   typedef typename RandomAccessHandleService::native_handle_type
     native_handle_type;
 
   /// Construct a basic_random_access_handle without opening it.
   /**
    * This constructor creates a random-access handle without opening it. The
-   * handle needs to be opened before data can be written to or or read from it.
+   * handle needs to be opened before data can be written to or read from it.
    *
    * @param io_service The io_service object that the random-access handle will
    * use to dispatch handlers for any asynchronous operations performed on the
    * handle.
    */
   explicit basic_random_access_handle(boost::asio::io_service& io_service)
@@ -153,13 +153,13 @@ public:
    * @endcode
    * See the @ref buffer documentation for information on writing multiple
    * buffers in one go, and how to use it with arrays, boost::array or
    * std::vector.
    */
   template <typename ConstBufferSequence>
-  std::size_t write_some_at(boost::uint64_t offset,
+  std::size_t write_some_at(uint64_t offset,
       const ConstBufferSequence& buffers)
   {
     boost::system::error_code ec;
     std::size_t s = this->get_service().write_some_at(
         this->get_implementation(), offset, buffers, ec);
     boost::asio::detail::throw_error(ec, "write_some_at");
@@ -182,13 +182,13 @@ public:
    *
    * @note The write_some operation may not transmit all of the data to the
    * peer. Consider using the @ref write_at function if you need to ensure that
    * all data is written before the blocking operation completes.
    */
   template <typename ConstBufferSequence>
-  std::size_t write_some_at(boost::uint64_t offset,
+  std::size_t write_some_at(uint64_t offset,
       const ConstBufferSequence& buffers, boost::system::error_code& ec)
   {
     return this->get_service().write_some_at(
         this->get_implementation(), offset, buffers, ec);
   }
 
@@ -227,21 +227,23 @@ public:
    * @endcode
    * See the @ref buffer documentation for information on writing multiple
    * buffers in one go, and how to use it with arrays, boost::array or
    * std::vector.
    */
   template <typename ConstBufferSequence, typename WriteHandler>
-  void async_write_some_at(boost::uint64_t offset,
+  BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,
+      void (boost::system::error_code, std::size_t))
+  async_write_some_at(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;
 
-    this->get_service().async_write_some_at(this->get_implementation(),
+    return this->get_service().async_write_some_at(this->get_implementation(),
         offset, buffers, BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
   }
 
   /// Read some data from the handle at the specified offset.
   /**
    * This function is used to read data from the random-access handle. The
@@ -270,13 +272,13 @@ public:
    * @endcode
    * See the @ref buffer documentation for information on reading into multiple
    * buffers in one go, and how to use it with arrays, boost::array or
    * std::vector.
    */
   template <typename MutableBufferSequence>
-  std::size_t read_some_at(boost::uint64_t offset,
+  std::size_t read_some_at(uint64_t offset,
       const MutableBufferSequence& buffers)
   {
     boost::system::error_code ec;
     std::size_t s = this->get_service().read_some_at(
         this->get_implementation(), offset, buffers, ec);
     boost::asio::detail::throw_error(ec, "read_some_at");
@@ -300,13 +302,13 @@ public:
    * @note The read_some operation may not read all of the requested number of
    * bytes. Consider using the @ref read_at function if you need to ensure that
    * the requested amount of data is read before the blocking operation
    * completes.
    */
   template <typename MutableBufferSequence>
-  std::size_t read_some_at(boost::uint64_t offset,
+  std::size_t read_some_at(uint64_t offset,
       const MutableBufferSequence& buffers, boost::system::error_code& ec)
   {
     return this->get_service().read_some_at(
         this->get_implementation(), offset, buffers, ec);
   }
 
@@ -346,21 +348,23 @@ public:
    * @endcode
    * See the @ref buffer documentation for information on reading into multiple
    * buffers in one go, and how to use it with arrays, boost::array or
    * std::vector.
    */
   template <typename MutableBufferSequence, typename ReadHandler>
-  void async_read_some_at(boost::uint64_t offset,
+  BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+      void (boost::system::error_code, std::size_t))
+  async_read_some_at(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;
 
-    this->get_service().async_read_some_at(this->get_implementation(),
+    return this->get_service().async_read_some_at(this->get_implementation(),
         offset, buffers, BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
   }
 };
 
 } // namespace windows
 } // namespace asio
diff --git a/3rdParty/Boost/src/boost/asio/windows/basic_stream_handle.hpp b/3rdParty/Boost/src/boost/asio/windows/basic_stream_handle.hpp
index ccc8f09..479707a 100644
--- a/3rdParty/Boost/src/boost/asio/windows/basic_stream_handle.hpp
+++ b/3rdParty/Boost/src/boost/asio/windows/basic_stream_handle.hpp
@@ -1,11 +1,11 @@
 //
 // windows/basic_stream_handle.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)
 //
 
 #ifndef BOOST_ASIO_WINDOWS_BASIC_STREAM_HANDLE_HPP
@@ -219,20 +219,22 @@ public:
    * @endcode
    * See the @ref buffer documentation for information on writing multiple
    * buffers in one go, and how to use it with arrays, boost::array or
    * std::vector.
    */
   template <typename ConstBufferSequence, typename WriteHandler>
-  void async_write_some(const ConstBufferSequence& buffers,
+  BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,
+      void (boost::system::error_code, std::size_t))
+  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;
 
-    this->get_service().async_write_some(this->get_implementation(),
+    return this->get_service().async_write_some(this->get_implementation(),
         buffers, BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
   }
 
   /// Read some data from the handle.
   /**
    * This function is used to read data from the stream handle. The function
@@ -330,20 +332,22 @@ public:
    * @endcode
    * See the @ref buffer documentation for information on reading into multiple
    * buffers in one go, and how to use it with arrays, boost::array or
    * std::vector.
    */
   template <typename MutableBufferSequence, typename ReadHandler>
-  void async_read_some(const MutableBufferSequence& buffers,
+  BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+      void (boost::system::error_code, std::size_t))
+  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;
 
-    this->get_service().async_read_some(this->get_implementation(),
+    return this->get_service().async_read_some(this->get_implementation(),
         buffers, BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
   }
 };
 
 } // namespace windows
 } // namespace asio
diff --git a/3rdParty/Boost/src/boost/asio/windows/object_handle.hpp b/3rdParty/Boost/src/boost/asio/windows/object_handle.hpp
index 7bf0654..307963e 100644
--- a/3rdParty/Boost/src/boost/asio/windows/object_handle.hpp
+++ b/3rdParty/Boost/src/boost/asio/windows/object_handle.hpp
@@ -1,11 +1,11 @@
 //
 // windows/object_handle.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) 2011 Boris Schaeling (boris@highscore.de)
 //
 // 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)
 //
 
diff --git a/3rdParty/Boost/src/boost/asio/windows/object_handle_service.hpp b/3rdParty/Boost/src/boost/asio/windows/object_handle_service.hpp
index ffc89e6..dd33277 100644
--- a/3rdParty/Boost/src/boost/asio/windows/object_handle_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/windows/object_handle_service.hpp
@@ -1,11 +1,11 @@
 //
 // windows/object_handle_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)
 // Copyright (c) 2011 Boris Schaeling (boris@highscore.de)
 //
 // 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,12 +18,13 @@
 
 #include <boost/asio/detail/config.hpp>
 
 #if defined(BOOST_ASIO_HAS_WINDOWS_OBJECT_HANDLE) \
   || defined(GENERATING_DOCUMENTATION)
 
+#include <boost/asio/async_result.hpp>
 #include <boost/asio/detail/win_object_handle_service.hpp>
 #include <boost/asio/error.hpp>
 #include <boost/asio/io_service.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
@@ -138,16 +139,24 @@ public:
   {
     service_impl_.wait(impl, ec);
   }
 
   /// Start an asynchronous wait.
   template <typename WaitHandler>
-  void async_wait(implementation_type& impl,
+  BOOST_ASIO_INITFN_RESULT_TYPE(WaitHandler,
+      void (boost::system::error_code))
+  async_wait(implementation_type& impl,
       BOOST_ASIO_MOVE_ARG(WaitHandler) handler)
   {
-    service_impl_.async_wait(impl, BOOST_ASIO_MOVE_CAST(WaitHandler)(handler));
+    boost::asio::detail::async_result_init<
+      WaitHandler, void (boost::system::error_code)> init(
+        BOOST_ASIO_MOVE_CAST(WaitHandler)(handler));
+
+    service_impl_.async_wait(impl, init.handler);
+
+    return init.result.get();
   }
 
 private:
   // Destroy all user-defined handler objects owned by the service.
   void shutdown_service()
   {
diff --git a/3rdParty/Boost/src/boost/asio/windows/overlapped_ptr.hpp b/3rdParty/Boost/src/boost/asio/windows/overlapped_ptr.hpp
index 94f9842..4c6d4ab 100644
--- a/3rdParty/Boost/src/boost/asio/windows/overlapped_ptr.hpp
+++ b/3rdParty/Boost/src/boost/asio/windows/overlapped_ptr.hpp
@@ -1,11 +1,11 @@
 //
 // windows/overlapped_ptr.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)
 //
 
 #ifndef BOOST_ASIO_WINDOWS_OVERLAPPED_PTR_HPP
diff --git a/3rdParty/Boost/src/boost/asio/windows/random_access_handle.hpp b/3rdParty/Boost/src/boost/asio/windows/random_access_handle.hpp
index 61fe1aa..e7dbfac 100644
--- a/3rdParty/Boost/src/boost/asio/windows/random_access_handle.hpp
+++ b/3rdParty/Boost/src/boost/asio/windows/random_access_handle.hpp
@@ -1,11 +1,11 @@
 //
 // windows/random_access_handle.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)
 //
 
 #ifndef BOOST_ASIO_WINDOWS_RANDOM_ACCESS_HANDLE_HPP
diff --git a/3rdParty/Boost/src/boost/asio/windows/random_access_handle_service.hpp b/3rdParty/Boost/src/boost/asio/windows/random_access_handle_service.hpp
index 9b5e456..bc013d9 100644
--- a/3rdParty/Boost/src/boost/asio/windows/random_access_handle_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/windows/random_access_handle_service.hpp
@@ -1,11 +1,11 @@
 //
 // windows/random_access_handle_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)
 //
 
 #ifndef BOOST_ASIO_WINDOWS_RANDOM_ACCESS_HANDLE_SERVICE_HPP
@@ -18,14 +18,14 @@
 #include <boost/asio/detail/config.hpp>
 
 #if defined(BOOST_ASIO_HAS_WINDOWS_RANDOM_ACCESS_HANDLE) \
   || defined(GENERATING_DOCUMENTATION)
 
 #include <cstddef>
-#include <boost/config.hpp>
-#include <boost/cstdint.hpp>
+#include <boost/asio/async_result.hpp>
+#include <boost/asio/detail/cstdint.hpp>
 #include <boost/asio/detail/win_iocp_handle_service.hpp>
 #include <boost/asio/error.hpp>
 #include <boost/asio/io_service.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
@@ -148,44 +148,58 @@ public:
   {
     return service_impl_.cancel(impl, ec);
   }
 
   /// Write the given data at the specified offset.
   template <typename ConstBufferSequence>
-  std::size_t write_some_at(implementation_type& impl, boost::uint64_t offset,
+  std::size_t write_some_at(implementation_type& impl, uint64_t offset,
       const ConstBufferSequence& buffers, boost::system::error_code& ec)
   {
     return service_impl_.write_some_at(impl, offset, buffers, ec);
   }
 
   /// Start an asynchronous write at the specified offset.
   template <typename ConstBufferSequence, typename WriteHandler>
-  void async_write_some_at(implementation_type& impl,
-      boost::uint64_t offset, const ConstBufferSequence& buffers,
+  BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,
+      void (boost::system::error_code, std::size_t))
+  async_write_some_at(implementation_type& impl,
+      uint64_t offset, const ConstBufferSequence& buffers,
       BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
   {
-    service_impl_.async_write_some_at(impl, offset, buffers,
+    boost::asio::detail::async_result_init<
+      WriteHandler, void (boost::system::error_code, std::size_t)> init(
         BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
+
+    service_impl_.async_write_some_at(impl, offset, buffers, init.handler);
+
+    return init.result.get();
   }
 
   /// Read some data from the specified offset.
   template <typename MutableBufferSequence>
-  std::size_t read_some_at(implementation_type& impl, boost::uint64_t offset,
+  std::size_t read_some_at(implementation_type& impl, uint64_t offset,
       const MutableBufferSequence& buffers, boost::system::error_code& ec)
   {
     return service_impl_.read_some_at(impl, offset, buffers, ec);
   }
 
   /// Start an asynchronous read at the specified offset.
   template <typename MutableBufferSequence, typename ReadHandler>
-  void async_read_some_at(implementation_type& impl,
-      boost::uint64_t offset, const MutableBufferSequence& buffers,
+  BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+      void (boost::system::error_code, std::size_t))
+  async_read_some_at(implementation_type& impl,
+      uint64_t offset, const MutableBufferSequence& buffers,
       BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
   {
-    service_impl_.async_read_some_at(impl, offset, buffers,
+    boost::asio::detail::async_result_init<
+      ReadHandler, void (boost::system::error_code, std::size_t)> init(
         BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
+
+    service_impl_.async_read_some_at(impl, offset, buffers, init.handler);
+
+    return init.result.get();
   }
 
 private:
   // Destroy all user-defined handler objects owned by the service.
   void shutdown_service()
   {
diff --git a/3rdParty/Boost/src/boost/asio/windows/stream_handle.hpp b/3rdParty/Boost/src/boost/asio/windows/stream_handle.hpp
index 7d829db..dad6b74 100644
--- a/3rdParty/Boost/src/boost/asio/windows/stream_handle.hpp
+++ b/3rdParty/Boost/src/boost/asio/windows/stream_handle.hpp
@@ -1,11 +1,11 @@
 //
 // windows/stream_handle.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)
 //
 
 #ifndef BOOST_ASIO_WINDOWS_STREAM_HANDLE_HPP
diff --git a/3rdParty/Boost/src/boost/asio/windows/stream_handle_service.hpp b/3rdParty/Boost/src/boost/asio/windows/stream_handle_service.hpp
index 7d0ec9c..87c3a20 100644
--- a/3rdParty/Boost/src/boost/asio/windows/stream_handle_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/windows/stream_handle_service.hpp
@@ -1,11 +1,11 @@
 //
 // windows/stream_handle_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)
 //
 
 #ifndef BOOST_ASIO_WINDOWS_STREAM_HANDLE_SERVICE_HPP
@@ -18,12 +18,13 @@
 #include <boost/asio/detail/config.hpp>
 
 #if defined(BOOST_ASIO_HAS_WINDOWS_STREAM_HANDLE) \
   || defined(GENERATING_DOCUMENTATION)
 
 #include <cstddef>
+#include <boost/asio/async_result.hpp>
 #include <boost/asio/detail/win_iocp_handle_service.hpp>
 #include <boost/asio/error.hpp>
 #include <boost/asio/io_service.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
@@ -153,36 +154,50 @@ public:
   {
     return service_impl_.write_some(impl, buffers, ec);
   }
 
   /// Start an asynchronous write.
   template <typename ConstBufferSequence, typename WriteHandler>
-  void async_write_some(implementation_type& impl,
+  BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,
+      void (boost::system::error_code, std::size_t))
+  async_write_some(implementation_type& impl,
       const ConstBufferSequence& buffers,
       BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
   {
-    service_impl_.async_write_some(impl, buffers,
+    boost::asio::detail::async_result_init<
+      WriteHandler, void (boost::system::error_code, std::size_t)> init(
         BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
+
+    service_impl_.async_write_some(impl, buffers, init.handler);
+
+    return init.result.get();
   }
 
   /// Read some data from the stream.
   template <typename MutableBufferSequence>
   std::size_t read_some(implementation_type& impl,
       const MutableBufferSequence& buffers, boost::system::error_code& ec)
   {
     return service_impl_.read_some(impl, buffers, ec);
   }
 
   /// Start an asynchronous read.
   template <typename MutableBufferSequence, typename ReadHandler>
-  void async_read_some(implementation_type& impl,
+  BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler,
+      void (boost::system::error_code, std::size_t))
+  async_read_some(implementation_type& impl,
       const MutableBufferSequence& buffers,
       BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
   {
-    service_impl_.async_read_some(impl, buffers,
+    boost::asio::detail::async_result_init<
+      ReadHandler, void (boost::system::error_code, std::size_t)> init(
         BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
+
+    service_impl_.async_read_some(impl, buffers, init.handler);
+
+    return init.result.get();
   }
 
 private:
   // Destroy all user-defined handler objects owned by the service.
   void shutdown_service()
   {
diff --git a/3rdParty/Boost/src/boost/asio/write.hpp b/3rdParty/Boost/src/boost/asio/write.hpp
index dd6cb34..fdde975 100644
--- a/3rdParty/Boost/src/boost/asio/write.hpp
+++ b/3rdParty/Boost/src/boost/asio/write.hpp
@@ -1,11 +1,11 @@
 //
 // 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)
 //
 
 #ifndef BOOST_ASIO_WRITE_HPP
@@ -14,12 +14,13 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 #include <cstddef>
+#include <boost/asio/async_result.hpp>
 #include <boost/asio/basic_streambuf_fwd.hpp>
 #include <boost/asio/error.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
@@ -203,13 +204,13 @@ std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
  */
 template <typename SyncWriteStream, typename ConstBufferSequence,
     typename CompletionCondition>
 std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
     CompletionCondition completion_condition, boost::system::error_code& ec);
 
-#if !defined(BOOST_NO_IOSTREAM)
+#if !defined(BOOST_ASIO_NO_IOSTREAM)
 
 /// Write all of the supplied data to a stream before returning.
 /**
  * This function is used to write a certain number of bytes of data to a stream.
  * The call will block until one of the following conditions is true:
  *
@@ -345,13 +346,13 @@ std::size_t write(SyncWriteStream& s, basic_streambuf<Allocator>& b,
  */
 template <typename SyncWriteStream, typename Allocator,
     typename CompletionCondition>
 std::size_t write(SyncWriteStream& s, basic_streambuf<Allocator>& b,
     CompletionCondition completion_condition, boost::system::error_code& ec);
 
-#endif // !defined(BOOST_NO_IOSTREAM)
+#endif // !defined(BOOST_ASIO_NO_IOSTREAM)
 
 /*@}*/
 /**
  * @defgroup async_write boost::asio::async_write
  *
  * @brief Start an asynchronous operation to write a certain amount of data to a
@@ -410,13 +411,15 @@ std::size_t write(SyncWriteStream& s, basic_streambuf<Allocator>& b,
  * See the @ref buffer documentation for information on writing multiple
  * buffers in one go, and how to use it with arrays, boost::array or
  * std::vector.
  */
 template <typename AsyncWriteStream, typename ConstBufferSequence,
     typename WriteHandler>
-void async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
+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);
 
 /// Start an asynchronous operation to write a certain amount of data to a
 /// stream.
 /**
  * This function is used to asynchronously write a certain number of bytes of
@@ -482,17 +485,19 @@ void async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
  * See the @ref buffer documentation for information on writing multiple
  * buffers in one go, and how to use it with arrays, boost::array or
  * std::vector.
  */
 template <typename AsyncWriteStream, typename ConstBufferSequence,
     typename CompletionCondition, typename WriteHandler>
-void async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
+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);
 
-#if !defined(BOOST_NO_IOSTREAM)
+#if !defined(BOOST_ASIO_NO_IOSTREAM)
 
 /// Start an asynchronous operation to write all of the supplied data to a
 /// stream.
 /**
  * This function is used to asynchronously write a certain number of bytes of
  * data to a stream. The function call always returns immediately. The
@@ -530,13 +535,15 @@ void async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
  * Regardless of whether the asynchronous operation completes immediately or
  * not, the handler will not be invoked from within this function. Invocation of
  * the handler will be performed in a manner equivalent to using
  * boost::asio::io_service::post().
  */
 template <typename AsyncWriteStream, typename Allocator, typename WriteHandler>
-void async_write(AsyncWriteStream& s, basic_streambuf<Allocator>& b,
+BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,
+    void (boost::system::error_code, std::size_t))
+async_write(AsyncWriteStream& s, basic_streambuf<Allocator>& b,
     BOOST_ASIO_MOVE_ARG(WriteHandler) handler);
 
 /// Start an asynchronous operation to write a certain amount of data to a
 /// stream.
 /**
  * This function is used to asynchronously write a certain number of bytes of
@@ -590,17 +597,19 @@ void async_write(AsyncWriteStream& s, basic_streambuf<Allocator>& b,
  * not, the handler will not be invoked from within this function. Invocation of
  * the handler will be performed in a manner equivalent to using
  * boost::asio::io_service::post().
  */
 template <typename AsyncWriteStream, typename Allocator,
     typename CompletionCondition, typename WriteHandler>
-void async_write(AsyncWriteStream& s, basic_streambuf<Allocator>& b,
+BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,
+    void (boost::system::error_code, std::size_t))
+async_write(AsyncWriteStream& s, basic_streambuf<Allocator>& b,
     CompletionCondition completion_condition,
     BOOST_ASIO_MOVE_ARG(WriteHandler) handler);
 
-#endif // !defined(BOOST_NO_IOSTREAM)
+#endif // !defined(BOOST_ASIO_NO_IOSTREAM)
 
 /*@}*/
 
 } // namespace asio
 } // namespace boost
 
diff --git a/3rdParty/Boost/src/boost/asio/write_at.hpp b/3rdParty/Boost/src/boost/asio/write_at.hpp
index 9535a55..6df000c 100644
--- a/3rdParty/Boost/src/boost/asio/write_at.hpp
+++ b/3rdParty/Boost/src/boost/asio/write_at.hpp
@@ -1,11 +1,11 @@
 //
 // 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)
 //
 
 #ifndef BOOST_ASIO_WRITE_AT_HPP
@@ -14,14 +14,15 @@
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
 #include <cstddef>
-#include <boost/cstdint.hpp>
+#include <boost/asio/async_result.hpp>
 #include <boost/asio/basic_streambuf_fwd.hpp>
+#include <boost/asio/detail/cstdint.hpp>
 #include <boost/asio/error.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
@@ -71,13 +72,13 @@ namespace asio {
  * @code boost::asio::write_at(
  *     d, offset, buffers,
  *     boost::asio::transfer_all()); @endcode
  */
 template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence>
 std::size_t write_at(SyncRandomAccessWriteDevice& d,
-    boost::uint64_t offset, const ConstBufferSequence& buffers);
+    uint64_t offset, const ConstBufferSequence& buffers);
 
 /// Write all of the supplied data at the specified offset before returning.
 /**
  * This function is used to write a certain number of bytes of data to a random
  * access device at a specified offset. The call will block until one of the
  * following conditions is true:
@@ -115,13 +116,13 @@ std::size_t write_at(SyncRandomAccessWriteDevice& d,
  * @code boost::asio::write_at(
  *     d, offset, buffers,
  *     boost::asio::transfer_all(), ec); @endcode
  */
 template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence>
 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);
 
 /// Write a certain amount of data at a specified offset before returning.
 /**
  * This function is used to write a certain number of bytes of data to a random
  * access device at a specified offset. The call will block until one of the
@@ -170,13 +171,13 @@ std::size_t write_at(SyncRandomAccessWriteDevice& d,
  * buffers in one go, and how to use it with arrays, boost::array or
  * std::vector.
  */
 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);
 
 /// Write a certain amount of data at a specified offset before returning.
 /**
  * This function is used to write a certain number of bytes of data to a random
  * access device at a specified offset. The call will block until one of the
@@ -218,16 +219,16 @@ std::size_t write_at(SyncRandomAccessWriteDevice& d,
  * @returns The number of bytes written. If an error occurs, returns the total
  * number of bytes successfully transferred prior to the error.
  */
 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);
 
-#if !defined(BOOST_NO_IOSTREAM)
+#if !defined(BOOST_ASIO_NO_IOSTREAM)
 
 /// Write all of the supplied data at the specified offset before returning.
 /**
  * This function is used to write a certain number of bytes of data to a random
  * access device at a specified offset. The call will block until one of the
  * following conditions is true:
@@ -254,13 +255,13 @@ std::size_t write_at(SyncRandomAccessWriteDevice& d,
  * @code boost::asio::write_at(
  *     d, 42, b,
  *     boost::asio::transfer_all()); @endcode
  */
 template <typename SyncRandomAccessWriteDevice, typename Allocator>
 std::size_t write_at(SyncRandomAccessWriteDevice& d,
-    boost::uint64_t offset, basic_streambuf<Allocator>& b);
+    uint64_t offset, basic_streambuf<Allocator>& b);
 
 /// Write all of the supplied data at the specified offset before returning.
 /**
  * This function is used to write a certain number of bytes of data to a random
  * access device at a specified offset. The call will block until one of the
  * following conditions is true:
@@ -287,13 +288,13 @@ std::size_t write_at(SyncRandomAccessWriteDevice& d,
  * @code boost::asio::write_at(
  *     d, 42, b,
  *     boost::asio::transfer_all(), ec); @endcode
  */
 template <typename SyncRandomAccessWriteDevice, typename Allocator>
 std::size_t write_at(SyncRandomAccessWriteDevice& d,
-    boost::uint64_t offset, basic_streambuf<Allocator>& b,
+    uint64_t offset, basic_streambuf<Allocator>& b,
     boost::system::error_code& ec);
 
 /// Write a certain amount of data at a specified offset before returning.
 /**
  * This function is used to write a certain number of bytes of data to a random
  * access device at a specified offset. The call will block until one of the
@@ -330,13 +331,13 @@ std::size_t write_at(SyncRandomAccessWriteDevice& d,
  * @returns The number of bytes transferred.
  *
  * @throws boost::system::system_error Thrown on failure.
  */
 template <typename SyncRandomAccessWriteDevice, typename Allocator,
     typename CompletionCondition>
-std::size_t write_at(SyncRandomAccessWriteDevice& d, boost::uint64_t offset,
+std::size_t write_at(SyncRandomAccessWriteDevice& d, uint64_t offset,
     basic_streambuf<Allocator>& b, CompletionCondition completion_condition);
 
 /// Write a certain amount of data at a specified offset before returning.
 /**
  * This function is used to write a certain number of bytes of data to a random
  * access device at a specified offset. The call will block until one of the
@@ -374,17 +375,17 @@ std::size_t write_at(SyncRandomAccessWriteDevice& d, boost::uint64_t offset,
  *
  * @returns The number of bytes written. If an error occurs, returns the total
  * number of bytes successfully transferred prior to the error.
  */
 template <typename SyncRandomAccessWriteDevice, typename Allocator,
     typename CompletionCondition>
-std::size_t write_at(SyncRandomAccessWriteDevice& d, boost::uint64_t offset,
+std::size_t write_at(SyncRandomAccessWriteDevice& d, uint64_t offset,
     basic_streambuf<Allocator>& b, CompletionCondition completion_condition,
     boost::system::error_code& ec);
 
-#endif // !defined(BOOST_NO_IOSTREAM)
+#endif // !defined(BOOST_ASIO_NO_IOSTREAM)
 
 /*@}*/
 /**
  * @defgroup async_write_at boost::asio::async_write_at
  *
  * @brief Start an asynchronous operation to write a certain amount of data at
@@ -403,13 +404,18 @@ std::size_t write_at(SyncRandomAccessWriteDevice& d, boost::uint64_t offset,
  * @li All of the data in the supplied buffers has been written. That is, the
  * bytes transferred is equal to the sum of the buffer sizes.
  *
  * @li An error occurred.
  *
  * This operation is implemented in terms of zero or more calls to the device's
- * async_write_some_at function.
+ * async_write_some_at function, and is known as a <em>composed operation</em>.
+ * The program must ensure that the device performs no <em>overlapping</em>
+ * write operations (such as async_write_at, the device's async_write_some_at
+ * function, or any other composed operations that perform writes) until this
+ * operation completes. Operations are overlapping if the regions defined by
+ * their offsets, and the numbers of bytes to write, intersect.
  *
  * @param d The device to which the data is to be written. The type must support
  * the AsyncRandomAccessWriteDevice concept.
  *
  * @param offset The offset at which the data will be written.
  *
@@ -442,13 +448,15 @@ std::size_t write_at(SyncRandomAccessWriteDevice& d, boost::uint64_t offset,
  * See the @ref buffer documentation for information on writing multiple
  * buffers in one go, and how to use it with arrays, boost::array or
  * std::vector.
  */
 template <typename AsyncRandomAccessWriteDevice, typename ConstBufferSequence,
     typename WriteHandler>
-void async_write_at(AsyncRandomAccessWriteDevice& d, boost::uint64_t offset,
+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);
 
 /// Start an asynchronous operation to write a certain amount of data at the
 /// specified offset.
 /**
@@ -460,13 +468,18 @@ void async_write_at(AsyncRandomAccessWriteDevice& d, boost::uint64_t offset,
  * @li All of the data in the supplied buffers has been written. That is, the
  * bytes transferred is equal to the sum of the buffer sizes.
  *
  * @li The completion_condition function object returns 0.
  *
  * This operation is implemented in terms of zero or more calls to the device's
- * async_write_some_at function.
+ * async_write_some_at function, and is known as a <em>composed operation</em>.
+ * The program must ensure that the device performs no <em>overlapping</em>
+ * write operations (such as async_write_at, the device's async_write_some_at
+ * function, or any other composed operations that perform writes) until this
+ * operation completes. Operations are overlapping if the regions defined by
+ * their offsets, and the numbers of bytes to write, intersect.
  *
  * @param d The device to which the data is to be written. The type must support
  * the AsyncRandomAccessWriteDevice concept.
  *
  * @param offset The offset at which the data will be written.
  *
@@ -514,18 +527,20 @@ void async_write_at(AsyncRandomAccessWriteDevice& d, boost::uint64_t offset,
  * See the @ref buffer documentation for information on writing multiple
  * buffers in one go, and how to use it with arrays, boost::array or
  * std::vector.
  */
 template <typename AsyncRandomAccessWriteDevice, typename ConstBufferSequence,
     typename CompletionCondition, typename WriteHandler>
-void async_write_at(AsyncRandomAccessWriteDevice& d,
-    boost::uint64_t offset, const ConstBufferSequence& buffers,
+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);
 
-#if !defined(BOOST_NO_IOSTREAM)
+#if !defined(BOOST_ASIO_NO_IOSTREAM)
 
 /// Start an asynchronous operation to write all of the supplied data at the
 /// specified offset.
 /**
  * This function is used to asynchronously write a certain number of bytes of
  * data to a random access device at a specified offset. The function call
@@ -534,13 +549,18 @@ void async_write_at(AsyncRandomAccessWriteDevice& d,
  *
  * @li All of the data in the supplied basic_streambuf has been written.
  *
  * @li An error occurred.
  *
  * This operation is implemented in terms of zero or more calls to the device's
- * async_write_some_at function.
+ * async_write_some_at function, and is known as a <em>composed operation</em>.
+ * The program must ensure that the device performs no <em>overlapping</em>
+ * write operations (such as async_write_at, the device's async_write_some_at
+ * function, or any other composed operations that perform writes) until this
+ * operation completes. Operations are overlapping if the regions defined by
+ * their offsets, and the numbers of bytes to write, intersect.
  *
  * @param d The device to which the data is to be written. The type must support
  * the AsyncRandomAccessWriteDevice concept.
  *
  * @param offset The offset at which the data will be written.
  *
@@ -563,13 +583,15 @@ void async_write_at(AsyncRandomAccessWriteDevice& d,
  * not, the handler will not be invoked from within this function. Invocation of
  * the handler will be performed in a manner equivalent to using
  * boost::asio::io_service::post().
  */
 template <typename AsyncRandomAccessWriteDevice, typename Allocator,
     typename WriteHandler>
-void async_write_at(AsyncRandomAccessWriteDevice& d, boost::uint64_t offset,
+BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,
+    void (boost::system::error_code, std::size_t))
+async_write_at(AsyncRandomAccessWriteDevice& d, uint64_t offset,
     basic_streambuf<Allocator>& b, BOOST_ASIO_MOVE_ARG(WriteHandler) handler);
 
 /// Start an asynchronous operation to write a certain amount of data at the
 /// specified offset.
 /**
  * This function is used to asynchronously write a certain number of bytes of
@@ -579,13 +601,18 @@ void async_write_at(AsyncRandomAccessWriteDevice& d, boost::uint64_t offset,
  *
  * @li All of the data in the supplied basic_streambuf has been written.
  *
  * @li The completion_condition function object returns 0.
  *
  * This operation is implemented in terms of zero or more calls to the device's
- * async_write_some_at function.
+ * async_write_some_at function, and is known as a <em>composed operation</em>.
+ * The program must ensure that the device performs no <em>overlapping</em>
+ * write operations (such as async_write_at, the device's async_write_some_at
+ * function, or any other composed operations that perform writes) until this
+ * operation completes. Operations are overlapping if the regions defined by
+ * their offsets, and the numbers of bytes to write, intersect.
  *
  * @param d The device to which the data is to be written. The type must support
  * the AsyncRandomAccessWriteDevice concept.
  *
  * @param offset The offset at which the data will be written.
  *
@@ -622,17 +649,19 @@ void async_write_at(AsyncRandomAccessWriteDevice& d, boost::uint64_t offset,
  * not, the handler will not be invoked from within this function. Invocation of
  * the handler will be performed in a manner equivalent to using
  * boost::asio::io_service::post().
  */
 template <typename AsyncRandomAccessWriteDevice, typename Allocator,
     typename CompletionCondition, typename WriteHandler>
-void async_write_at(AsyncRandomAccessWriteDevice& d, boost::uint64_t offset,
+BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,
+    void (boost::system::error_code, std::size_t))
+async_write_at(AsyncRandomAccessWriteDevice& d, uint64_t offset,
     basic_streambuf<Allocator>& b, CompletionCondition completion_condition,
     BOOST_ASIO_MOVE_ARG(WriteHandler) handler);
 
-#endif // !defined(BOOST_NO_IOSTREAM)
+#endif // !defined(BOOST_ASIO_NO_IOSTREAM)
 
 /*@}*/
 
 } // namespace asio
 } // namespace boost
author	Tobias Markmann <tm@ayena.de>	2014-10-19 20:22:58 (GMT)
committer	Tobias Markmann <tm@ayena.de>	2014-10-20 13:49:33 (GMT)
commit	6b22dfcf59474dd016a0355a3102a1dd3692d92c (patch)
tree	2b1fd33be433a91e81fee84fdc2bf1b52575d934 /3rdParty/Boost/src/boost/asio
parent	38b0cb785fea8eae5e48fae56440695fdfd10ee1 (diff)
download	swift-6b22dfcf59474dd016a0355a3102a1dd3692d92c.zip swift-6b22dfcf59474dd016a0355a3102a1dd3692d92c.tar.bz2