311 files changed, 2784 insertions, 18440 deletions
diff --git a/3rdParty/Boost/src/boost/asio/basic_datagram_socket.hpp b/3rdParty/Boost/src/boost/asio/basic_datagram_socket.hpp
index a773315..a79967f 100644
--- a/3rdParty/Boost/src/boost/asio/basic_datagram_socket.hpp
+++ b/3rdParty/Boost/src/boost/asio/basic_datagram_socket.hpp
@@ -1,86 +1,81 @@
 //
 // basic_datagram_socket.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_BASIC_DATAGRAM_SOCKET_HPP
 #define BOOST_ASIO_BASIC_DATAGRAM_SOCKET_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/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/error.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 
 /// Provides datagram-oriented socket functionality.
 /**
  * The basic_datagram_socket class template provides asynchronous and blocking
  * datagram-oriented socket functionality.
  *
  * @par Thread Safety
  * @e Distinct @e objects: Safe.@n
  * @e Shared @e objects: Unsafe.
  */
 template <typename Protocol,
     typename DatagramSocketService = datagram_socket_service<Protocol> >
 class basic_datagram_socket
   : public basic_socket<Protocol, DatagramSocketService>
 {
 public:
-  /// (Deprecated: Use native_handle_type.) The native representation of a
-  /// socket.
-  typedef typename DatagramSocketService::native_handle_type native_type;
-
   /// The native representation of a socket.
-  typedef typename DatagramSocketService::native_handle_type native_handle_type;
+  typedef typename DatagramSocketService::native_type native_type;
 
   /// The protocol type.
   typedef Protocol protocol_type;
 
   /// The endpoint type.
   typedef typename Protocol::endpoint endpoint_type;
 
   /// Construct a basic_datagram_socket without opening it.
   /**
    * This constructor creates a datagram socket without opening it. The open()
    * function must be called before data can be sent or received on the socket.
    *
    * @param io_service The io_service object that the datagram socket will use
    * to dispatch handlers for any asynchronous operations performed on the
    * socket.
    */
   explicit basic_datagram_socket(boost::asio::io_service& io_service)
     : basic_socket<Protocol, DatagramSocketService>(io_service)
   {
   }
 
   /// Construct and open a basic_datagram_socket.
   /**
    * This constructor creates and opens a datagram socket.
    *
    * @param io_service The io_service object that the datagram socket will use
    * to dispatch handlers for any asynchronous operations performed on the
    * socket.
    *
    * @param protocol An object specifying protocol parameters to be used.
    *
    * @throws boost::system::system_error Thrown on failure.
    */
   basic_datagram_socket(boost::asio::io_service& io_service,
       const protocol_type& protocol)
@@ -94,795 +89,714 @@ public:
    * This constructor creates a datagram socket and automatically opens it bound
    * to the specified endpoint on the local machine. The protocol used is the
    * protocol associated with the given endpoint.
    *
    * @param io_service The io_service object that the datagram socket will use
    * to dispatch handlers for any asynchronous operations performed on the
    * socket.
    *
    * @param endpoint An endpoint on the local machine to which the datagram
    * socket will be bound.
    *
    * @throws boost::system::system_error Thrown on failure.
    */
   basic_datagram_socket(boost::asio::io_service& io_service,
       const endpoint_type& endpoint)
     : basic_socket<Protocol, DatagramSocketService>(io_service, endpoint)
   {
   }
 
   /// Construct a basic_datagram_socket on an existing native socket.
   /**
    * This constructor creates a datagram socket object to hold an existing
    * native socket.
    *
    * @param io_service The io_service object that the datagram socket will use
    * to dispatch handlers for any asynchronous operations performed on the
    * socket.
    *
    * @param protocol An object specifying protocol parameters to be used.
    *
    * @param native_socket The new underlying socket implementation.
    *
    * @throws boost::system::system_error Thrown on failure.
    */
   basic_datagram_socket(boost::asio::io_service& io_service,
-      const protocol_type& protocol, const native_handle_type& native_socket)
+      const protocol_type& protocol, const native_type& native_socket)
     : basic_socket<Protocol, DatagramSocketService>(
         io_service, protocol, native_socket)
   {
   }
 
-#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
-  /// Move-construct a basic_datagram_socket from another.
-  /**
-   * 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.
-   */
-  basic_datagram_socket(basic_datagram_socket&& other)
-    : basic_socket<Protocol, DatagramSocketService>(
-        BOOST_ASIO_MOVE_CAST(basic_datagram_socket)(other))
-  {
-  }
-
-  /// Move-assign a basic_datagram_socket from another.
-  /**
-   * 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.
-   */
-  basic_datagram_socket& operator=(basic_datagram_socket&& other)
-  {
-    basic_socket<Protocol, DatagramSocketService>::operator=(
-        BOOST_ASIO_MOVE_CAST(basic_datagram_socket)(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
    * occurs.
    *
    * @param buffers One ore more data buffers to be sent on the socket.
    *
    * @returns The number of bytes sent.
    *
    * @throws boost::system::system_error Thrown on failure.
    *
    * @note The send operation can only be used with a connected socket. Use
    * the send_to function to send data on an unconnected datagram socket.
    *
    * @par Example
    * To send a single data buffer use the @ref buffer function as follows:
    * @code socket.send(boost::asio::buffer(data, size)); @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>
   std::size_t send(const ConstBufferSequence& buffers)
   {
     boost::system::error_code ec;
-    std::size_t s = this->get_service().send(
-        this->get_implementation(), buffers, 0, ec);
-    boost::asio::detail::throw_error(ec, "send");
+    std::size_t s = this->service.send(this->implementation, buffers, 0, ec);
+    boost::asio::detail::throw_error(ec);
     return s;
   }
 
   /// 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
    * occurs.
    *
    * @param buffers One ore more data buffers to be sent on the socket.
    *
    * @param flags Flags specifying how the send call is to be made.
    *
    * @returns The number of bytes sent.
    *
    * @throws boost::system::system_error Thrown on failure.
    *
    * @note The send operation can only be used with a connected socket. Use
    * the send_to function to send data on an unconnected datagram socket.
    */
   template <typename ConstBufferSequence>
   std::size_t send(const ConstBufferSequence& buffers,
       socket_base::message_flags flags)
   {
     boost::system::error_code ec;
-    std::size_t s = this->get_service().send(
-        this->get_implementation(), buffers, flags, ec);
-    boost::asio::detail::throw_error(ec, "send");
+    std::size_t s = this->service.send(
+        this->implementation, buffers, flags, ec);
+    boost::asio::detail::throw_error(ec);
     return s;
   }
 
   /// 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
    * occurs.
    *
    * @param buffers One or more data buffers to be sent on the socket.
    *
    * @param flags Flags specifying how the send call is to be made.
    *
    * @param ec Set to indicate what error occurred, if any.
    *
    * @returns The number of bytes sent.
    *
    * @note The send operation can only be used with a connected socket. Use
    * the send_to function to send data on an unconnected datagram socket.
    */
   template <typename ConstBufferSequence>
   std::size_t send(const ConstBufferSequence& buffers,
       socket_base::message_flags flags, boost::system::error_code& ec)
   {
-    return this->get_service().send(
-        this->get_implementation(), buffers, flags, ec);
+    return this->service.send(this->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.
    *
    * @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.
    *
    * @param handler The handler to be called when the send operation completes.
    * Copies will be made of the handler as required. The function signature of
    * the handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
    *   std::size_t bytes_transferred           // Number of bytes sent.
    * ); @endcode
    * 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().
    *
    * @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.
    *
    * @par Example
    * To send a single data buffer use the @ref buffer function as follows:
    * @code
    * socket.async_send(boost::asio::buffer(data, size), handler);
    * @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_MOVE_ARG(WriteHandler) handler)
+  void async_send(const ConstBufferSequence& buffers, 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, BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
+    this->service.async_send(this->implementation, buffers, 0, 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.
    *
    * @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.
    *
    * @param flags Flags specifying how the send call is to be made.
    *
    * @param handler The handler to be called when the send operation completes.
    * Copies will be made of the handler as required. The function signature of
    * the handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
    *   std::size_t bytes_transferred           // Number of bytes sent.
    * ); @endcode
    * 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().
    *
    * @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,
-      socket_base::message_flags flags,
-      BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
+      socket_base::message_flags flags, 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, BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
+    this->service.async_send(this->implementation, buffers, flags, handler);
   }
 
   /// Send a datagram to the specified endpoint.
   /**
    * This function is used to send a datagram to the specified remote endpoint.
    * The function call will block until the data has been sent successfully or
    * an error occurs.
    *
    * @param buffers One or more data buffers to be sent to the remote endpoint.
    *
    * @param destination The remote endpoint to which the data will be sent.
    *
    * @returns The number of bytes sent.
    *
    * @throws boost::system::system_error Thrown on failure.
    *
    * @par Example
    * To send a single data buffer use the @ref buffer function as follows:
    * @code
    * boost::asio::ip::udp::endpoint destination(
    *     boost::asio::ip::address::from_string("1.2.3.4"), 12345);
    * socket.send_to(boost::asio::buffer(data, size), destination);
    * @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>
   std::size_t send_to(const ConstBufferSequence& buffers,
       const endpoint_type& destination)
   {
     boost::system::error_code ec;
-    std::size_t s = this->get_service().send_to(
-        this->get_implementation(), buffers, destination, 0, ec);
-    boost::asio::detail::throw_error(ec, "send_to");
+    std::size_t s = this->service.send_to(
+        this->implementation, buffers, destination, 0, ec);
+    boost::asio::detail::throw_error(ec);
     return s;
   }
 
   /// Send a datagram to the specified endpoint.
   /**
    * This function is used to send a datagram to the specified remote endpoint.
    * The function call will block until the data has been sent successfully or
    * an error occurs.
    *
    * @param buffers One or more data buffers to be sent to the remote endpoint.
    *
    * @param destination The remote endpoint to which the data will be sent.
    *
    * @param flags Flags specifying how the send call is to be made.
    *
    * @returns The number of bytes sent.
    *
    * @throws boost::system::system_error Thrown on failure.
    */
   template <typename ConstBufferSequence>
   std::size_t send_to(const ConstBufferSequence& buffers,
       const endpoint_type& destination, socket_base::message_flags flags)
   {
     boost::system::error_code ec;
-    std::size_t s = this->get_service().send_to(
-        this->get_implementation(), buffers, destination, flags, ec);
-    boost::asio::detail::throw_error(ec, "send_to");
+    std::size_t s = this->service.send_to(
+        this->implementation, buffers, destination, flags, ec);
+    boost::asio::detail::throw_error(ec);
     return s;
   }
 
   /// Send a datagram to the specified endpoint.
   /**
    * This function is used to send a datagram to the specified remote endpoint.
    * The function call will block until the data has been sent successfully or
    * an error occurs.
    *
    * @param buffers One or more data buffers to be sent to the remote endpoint.
    *
    * @param destination The remote endpoint to which the data will be sent.
    *
    * @param flags Flags specifying how the send call is to be made.
    *
    * @param ec Set to indicate what error occurred, if any.
    *
    * @returns The number of bytes sent.
    */
   template <typename ConstBufferSequence>
   std::size_t send_to(const ConstBufferSequence& buffers,
       const endpoint_type& destination, socket_base::message_flags flags,
       boost::system::error_code& ec)
   {
-    return this->get_service().send_to(this->get_implementation(),
+    return this->service.send_to(this->implementation,
         buffers, destination, flags, ec);
   }
 
   /// Start an asynchronous send.
   /**
    * This function is used to asynchronously send a datagram to the specified
    * remote endpoint. The function call always returns immediately.
    *
    * @param buffers One or more data buffers to be sent to the remote endpoint.
    * 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.
    *
    * @param destination The remote endpoint to which the data will be sent.
    * Copies will be made of the endpoint as required.
    *
    * @param handler The handler to be called when the send operation completes.
    * Copies will be made of the handler as required. The function signature of
    * the handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
    *   std::size_t bytes_transferred           // Number of bytes sent.
    * ); @endcode
    * 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().
    *
    * @par Example
    * To send a single data buffer use the @ref buffer function as follows:
    * @code
    * boost::asio::ip::udp::endpoint destination(
    *     boost::asio::ip::address::from_string("1.2.3.4"), 12345);
    * socket.async_send_to(
    *     boost::asio::buffer(data, size), destination, handler);
    * @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,
-      const endpoint_type& destination,
-      BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
+      const endpoint_type& destination, 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));
+    this->service.async_send_to(this->implementation, buffers, destination, 0,
+        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.
    *
    * @param buffers One or more data buffers to be sent to the remote endpoint.
    * 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.
    *
    * @param flags Flags specifying how the send call is to be made.
    *
    * @param destination The remote endpoint to which the data will be sent.
    * Copies will be made of the endpoint as required.
    *
    * @param handler The handler to be called when the send operation completes.
    * Copies will be made of the handler as required. The function signature of
    * the handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
    *   std::size_t bytes_transferred           // Number of bytes sent.
    * ); @endcode
    * 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,
       const endpoint_type& destination, socket_base::message_flags flags,
-      BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
+      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));
+    this->service.async_send_to(this->implementation, buffers, destination,
+        flags, 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
    * occurs.
    *
    * @param buffers One or more buffers into which the data will be received.
    *
    * @returns The number of bytes received.
    *
    * @throws boost::system::system_error Thrown on failure.
    *
    * @note The receive operation can only be used with a connected socket. Use
    * the receive_from function to receive data on an unconnected datagram
    * socket.
    *
    * @par Example
    * To receive into a single data buffer use the @ref buffer function as
    * follows:
    * @code socket.receive(boost::asio::buffer(data, size)); @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>
   std::size_t receive(const MutableBufferSequence& buffers)
   {
     boost::system::error_code ec;
-    std::size_t s = this->get_service().receive(
-        this->get_implementation(), buffers, 0, ec);
-    boost::asio::detail::throw_error(ec, "receive");
+    std::size_t s = this->service.receive(
+        this->implementation, buffers, 0, ec);
+    boost::asio::detail::throw_error(ec);
     return s;
   }
 
   /// 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
    * occurs.
    *
    * @param buffers One or more buffers into which the data will be received.
    *
    * @param flags Flags specifying how the receive call is to be made.
    *
    * @returns The number of bytes received.
    *
    * @throws boost::system::system_error Thrown on failure.
    *
    * @note The receive operation can only be used with a connected socket. Use
    * the receive_from function to receive data on an unconnected datagram
    * socket.
    */
   template <typename MutableBufferSequence>
   std::size_t receive(const MutableBufferSequence& buffers,
       socket_base::message_flags flags)
   {
     boost::system::error_code ec;
-    std::size_t s = this->get_service().receive(
-        this->get_implementation(), buffers, flags, ec);
-    boost::asio::detail::throw_error(ec, "receive");
+    std::size_t s = this->service.receive(
+        this->implementation, buffers, flags, ec);
+    boost::asio::detail::throw_error(ec);
     return s;
   }
 
   /// 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
    * occurs.
    *
    * @param buffers One or more buffers into which the data will be received.
    *
    * @param flags Flags specifying how the receive call is to be made.
    *
    * @param ec Set to indicate what error occurred, if any.
    *
    * @returns The number of bytes received.
    *
    * @note The receive operation can only be used with a connected socket. Use
    * the receive_from function to receive data on an unconnected datagram
    * socket.
    */
   template <typename MutableBufferSequence>
   std::size_t receive(const MutableBufferSequence& buffers,
       socket_base::message_flags flags, boost::system::error_code& ec)
   {
-    return this->get_service().receive(
-        this->get_implementation(), buffers, flags, ec);
+    return this->service.receive(this->implementation, buffers, flags, ec);
   }
 
   /// Start an asynchronous receive on a connected socket.
   /**
    * This function is used to asynchronously receive data from the datagram
    * socket. The function call always returns immediately.
    *
    * @param buffers One or more buffers into which the data will be received.
    * 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.
    *
    * @param handler The handler to be called when the receive operation
    * completes. Copies will be made of the handler as required. The function
    * signature of the handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
    *   std::size_t bytes_transferred           // Number of bytes received.
    * ); @endcode
    * 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().
    *
    * @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.
    *
    * @par Example
    * To receive into a single data buffer use the @ref buffer function as
    * follows:
    * @code
    * socket.async_receive(boost::asio::buffer(data, size), 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(const MutableBufferSequence& buffers,
-      BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+  void async_receive(const MutableBufferSequence& buffers, 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, BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
+    this->service.async_receive(this->implementation, buffers, 0, handler);
   }
 
   /// Start an asynchronous receive on a connected socket.
   /**
    * This function is used to asynchronously receive data from the datagram
    * socket. The function call always returns immediately.
    *
    * @param buffers One or more buffers into which the data will be received.
    * 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.
    *
    * @param flags Flags specifying how the receive call is to be made.
    *
    * @param handler The handler to be called when the receive operation
    * completes. Copies will be made of the handler as required. The function
    * signature of the handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
    *   std::size_t bytes_transferred           // Number of bytes received.
    * ); @endcode
    * 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().
    *
    * @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,
-      socket_base::message_flags flags,
-      BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+      socket_base::message_flags flags, 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, flags, BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
+    this->service.async_receive(this->implementation, buffers, flags, handler);
   }
 
   /// Receive a datagram with the endpoint of the sender.
   /**
    * This function is used to receive a datagram. The function call will block
    * until data has been received successfully or an error occurs.
    *
    * @param buffers One or more buffers into which the data will be received.
    *
    * @param sender_endpoint An endpoint object that receives the endpoint of
    * the remote sender of the datagram.
    *
    * @returns The number of bytes received.
    *
    * @throws boost::system::system_error Thrown on failure.
    *
    * @par Example
    * To receive into a single data buffer use the @ref buffer function as
    * follows:
    * @code
    * boost::asio::ip::udp::endpoint sender_endpoint;
    * socket.receive_from(
    *     boost::asio::buffer(data, size), sender_endpoint);
    * @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>
   std::size_t receive_from(const MutableBufferSequence& buffers,
       endpoint_type& sender_endpoint)
   {
     boost::system::error_code ec;
-    std::size_t s = this->get_service().receive_from(
-        this->get_implementation(), buffers, sender_endpoint, 0, ec);
-    boost::asio::detail::throw_error(ec, "receive_from");
+    std::size_t s = this->service.receive_from(
+        this->implementation, buffers, sender_endpoint, 0, ec);
+    boost::asio::detail::throw_error(ec);
     return s;
   }
   
   /// Receive a datagram with the endpoint of the sender.
   /**
    * This function is used to receive a datagram. The function call will block
    * until data has been received successfully or an error occurs.
    *
    * @param buffers One or more buffers into which the data will be received.
    *
    * @param sender_endpoint An endpoint object that receives the endpoint of
    * the remote sender of the datagram.
    *
    * @param flags Flags specifying how the receive call is to be made.
    *
    * @returns The number of bytes received.
    *
    * @throws boost::system::system_error Thrown on failure.
    */
   template <typename MutableBufferSequence>
   std::size_t receive_from(const MutableBufferSequence& buffers,
       endpoint_type& sender_endpoint, socket_base::message_flags flags)
   {
     boost::system::error_code ec;
-    std::size_t s = this->get_service().receive_from(
-        this->get_implementation(), buffers, sender_endpoint, flags, ec);
-    boost::asio::detail::throw_error(ec, "receive_from");
+    std::size_t s = this->service.receive_from(
+        this->implementation, buffers, sender_endpoint, flags, ec);
+    boost::asio::detail::throw_error(ec);
     return s;
   }
   
   /// Receive a datagram with the endpoint of the sender.
   /**
    * This function is used to receive a datagram. The function call will block
    * until data has been received successfully or an error occurs.
    *
    * @param buffers One or more buffers into which the data will be received.
    *
    * @param sender_endpoint An endpoint object that receives the endpoint of
    * the remote sender of the datagram.
    *
    * @param flags Flags specifying how the receive call is to be made.
    *
    * @param ec Set to indicate what error occurred, if any.
    *
    * @returns The number of bytes received.
    */
   template <typename MutableBufferSequence>
   std::size_t receive_from(const MutableBufferSequence& buffers,
       endpoint_type& sender_endpoint, socket_base::message_flags flags,
       boost::system::error_code& ec)
   {
-    return this->get_service().receive_from(this->get_implementation(),
-        buffers, sender_endpoint, flags, ec);
+    return this->service.receive_from(this->implementation, buffers,
+        sender_endpoint, flags, ec);
   }
 
   /// Start an asynchronous receive.
   /**
    * This function is used to asynchronously receive a datagram. The function
    * call always returns immediately.
    *
    * @param buffers One or more buffers into which the data will be received.
    * 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.
    *
    * @param sender_endpoint An endpoint object that receives the endpoint of
    * the remote sender of the datagram. Ownership of the sender_endpoint object
    * is retained by the caller, which must guarantee that it is valid until the
    * handler is called.
    *
    * @param handler The handler to be called when the receive operation
    * completes. Copies will be made of the handler as required. The function
    * signature of the handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
    *   std::size_t bytes_transferred           // Number of bytes received.
    * ); @endcode
    * 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().
    *
    * @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
    * 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,
-      endpoint_type& sender_endpoint,
-      BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+      endpoint_type& sender_endpoint, 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));
+    this->service.async_receive_from(this->implementation, buffers,
+        sender_endpoint, 0, handler);
   }
 
   /// Start an asynchronous receive.
   /**
    * This function is used to asynchronously receive a datagram. The function
    * call always returns immediately.
    *
    * @param buffers One or more buffers into which the data will be received.
    * 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.
    *
    * @param sender_endpoint An endpoint object that receives the endpoint of
    * the remote sender of the datagram. Ownership of the sender_endpoint object
    * is retained by the caller, which must guarantee that it is valid until the
    * handler is called.
    *
    * @param flags Flags specifying how the receive call is to be made.
    *
    * @param handler The handler to be called when the receive operation
    * completes. Copies will be made of the handler as required. The function
    * signature of the handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
    *   std::size_t bytes_transferred           // Number of bytes received.
    * ); @endcode
    * 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,
       endpoint_type& sender_endpoint, socket_base::message_flags flags,
-      BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+      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));
+    this->service.async_receive_from(this->implementation, buffers,
+        sender_endpoint, flags, handler);
   }
 };
 
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // BOOST_ASIO_BASIC_DATAGRAM_SOCKET_HPP
diff --git a/3rdParty/Boost/src/boost/asio/basic_deadline_timer.hpp b/3rdParty/Boost/src/boost/asio/basic_deadline_timer.hpp
index 6baeb7a..452999d 100644
--- a/3rdParty/Boost/src/boost/asio/basic_deadline_timer.hpp
+++ b/3rdParty/Boost/src/boost/asio/basic_deadline_timer.hpp
@@ -1,57 +1,56 @@
 //
 // basic_deadline_timer.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_BASIC_DEADLINE_TIMER_HPP
 #define BOOST_ASIO_BASIC_DEADLINE_TIMER_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/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>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 
 /// Provides waitable timer functionality.
 /**
  * The basic_deadline_timer class template provides the ability to perform a
  * blocking or asynchronous wait for a timer to expire.
  *
  * A deadline 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::deadline_timer typedef.
  *
  * @par Thread Safety
  * @e Distinct @e objects: Safe.@n
  * @e Shared @e objects: Unsafe.
  *
  * @par Examples
  * Performing a blocking wait:
  * @code
  * // Construct a timer without setting an expiry time.
  * boost::asio::deadline_timer timer(io_service);
  *
  * // Set an expiry time relative to now.
  * timer.expires_from_now(boost::posix_time::seconds(5));
  *
  * // Wait for the timer to expire.
  * timer.wait();
  * @endcode
@@ -130,382 +129,316 @@ public:
   typedef typename traits_type::time_type time_type;
 
   /// The duration type.
   typedef typename traits_type::duration_type duration_type;
 
   /// Constructor.
   /**
    * This constructor creates a timer without setting an expiry time. The
    * expires_at() or expires_from_now() functions must be called to set an
    * expiry time before the timer can be waited on.
    *
    * @param io_service The io_service object that the timer will use to dispatch
    * handlers for any asynchronous operations performed on the timer.
    */
   explicit basic_deadline_timer(boost::asio::io_service& io_service)
     : basic_io_object<TimerService>(io_service)
   {
   }
 
   /// Constructor to set a particular expiry time as an absolute time.
   /**
    * This constructor creates a timer and sets the expiry time.
    *
    * @param io_service The io_service object that the timer will use to dispatch
    * handlers for any asynchronous operations performed on the timer.
    *
    * @param expiry_time The expiry time to be used for the timer, expressed
    * as an absolute time.
    */
   basic_deadline_timer(boost::asio::io_service& io_service,
       const time_type& expiry_time)
     : basic_io_object<TimerService>(io_service)
   {
     boost::system::error_code ec;
     this->service.expires_at(this->implementation, expiry_time, ec);
-    boost::asio::detail::throw_error(ec, "expires_at");
+    boost::asio::detail::throw_error(ec);
   }
 
   /// Constructor to set a particular expiry time relative to now.
   /**
    * This constructor creates a timer and sets the expiry time.
    *
    * @param io_service The io_service object that the timer will use to dispatch
    * handlers for any asynchronous operations performed on the timer.
    *
    * @param expiry_time The expiry time to be used for the timer, relative to
    * now.
    */
   basic_deadline_timer(boost::asio::io_service& io_service,
       const duration_type& expiry_time)
     : basic_io_object<TimerService>(io_service)
   {
     boost::system::error_code ec;
     this->service.expires_from_now(this->implementation, expiry_time, ec);
-    boost::asio::detail::throw_error(ec, "expires_from_now");
+    boost::asio::detail::throw_error(ec);
   }
 
   /// Cancel any asynchronous operations that are waiting on the timer.
   /**
    * This function forces the completion of any pending asynchronous wait
    * operations against the timer. The handler for each cancelled operation will
    * be invoked with the boost::asio::error::operation_aborted error code.
    *
    * Cancelling the timer does not change the expiry time.
    *
    * @return The number of asynchronous operations that were cancelled.
    *
    * @throws boost::system::system_error Thrown on failure.
    *
    * @note If the timer has already expired when cancel() is called, then the
    * handlers for asynchronous wait operations will:
    *
    * @li have already been invoked; or
    *
    * @li have been queued for invocation in the near future.
    *
    * These handlers can no longer be cancelled, and therefore are passed an
    * error code that indicates the successful completion of the wait operation.
    */
   std::size_t cancel()
   {
     boost::system::error_code ec;
     std::size_t s = this->service.cancel(this->implementation, ec);
-    boost::asio::detail::throw_error(ec, "cancel");
+    boost::asio::detail::throw_error(ec);
     return s;
   }
 
   /// Cancel any asynchronous operations that are waiting on the timer.
   /**
    * This function forces the completion of any pending asynchronous wait
    * operations against the timer. The handler for each cancelled operation will
    * be invoked with the boost::asio::error::operation_aborted error code.
    *
    * Cancelling the timer does not change the expiry time.
    *
    * @param ec Set to indicate what error occurred, if any.
    *
    * @return The number of asynchronous operations that were cancelled.
    *
    * @note If the timer has already expired when cancel() is called, then the
    * handlers for asynchronous wait operations will:
    *
    * @li have already been invoked; or
    *
    * @li have been queued for invocation in the near future.
    *
    * These handlers can no longer be cancelled, and therefore are passed an
    * error code that indicates the successful completion of the wait operation.
    */
   std::size_t cancel(boost::system::error_code& ec)
   {
     return this->service.cancel(this->implementation, ec);
   }
 
-  /// Cancels one asynchronous operation that is waiting on the timer.
-  /**
-   * This function forces the completion of one pending asynchronous wait
-   * operation against the timer. Handlers are cancelled in FIFO order. The
-   * handler for the cancelled operation will be invoked with the
-   * boost::asio::error::operation_aborted error code.
-   *
-   * Cancelling the timer does not change the expiry time.
-   *
-   * @return The number of asynchronous operations that were cancelled. That is,
-   * either 0 or 1.
-   *
-   * @throws boost::system::system_error Thrown on failure.
-   *
-   * @note If the timer has already expired when cancel_one() is called, then
-   * the handlers for asynchronous wait operations will:
-   *
-   * @li have already been invoked; or
-   *
-   * @li have been queued for invocation in the near future.
-   *
-   * These handlers can no longer be cancelled, and therefore are passed an
-   * error code that indicates the successful completion of the wait operation.
-   */
-  std::size_t cancel_one()
-  {
-    boost::system::error_code ec;
-    std::size_t s = this->service.cancel_one(this->implementation, ec);
-    boost::asio::detail::throw_error(ec, "cancel_one");
-    return s;
-  }
-
-  /// Cancels one asynchronous operation that is waiting on the timer.
-  /**
-   * This function forces the completion of one pending asynchronous wait
-   * operation against the timer. Handlers are cancelled in FIFO order. The
-   * handler for the cancelled operation will be invoked with the
-   * boost::asio::error::operation_aborted error code.
-   *
-   * Cancelling the timer does not change the expiry time.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @return The number of asynchronous operations that were cancelled. That is,
-   * either 0 or 1.
-   *
-   * @note If the timer has already expired when cancel_one() is called, then
-   * the handlers for asynchronous wait operations will:
-   *
-   * @li have already been invoked; or
-   *
-   * @li have been queued for invocation in the near future.
-   *
-   * These handlers can no longer be cancelled, and therefore are passed an
-   * error code that indicates the successful completion of the wait operation.
-   */
-  std::size_t cancel_one(boost::system::error_code& ec)
-  {
-    return this->service.cancel_one(this->implementation, ec);
-  }
-
   /// Get the timer's expiry time as an absolute time.
   /**
    * This function may be used to obtain the timer's current expiry time.
    * Whether the timer has expired or not does not affect this value.
    */
   time_type expires_at() const
   {
     return this->service.expires_at(this->implementation);
   }
 
   /// Set the timer's expiry time as an absolute time.
   /**
    * This function sets the expiry time. Any pending asynchronous wait
    * operations will be cancelled. The handler for each cancelled operation will
    * be invoked with the boost::asio::error::operation_aborted error code.
    *
    * @param expiry_time The expiry time to be used for the timer.
    *
    * @return The number of asynchronous operations that were cancelled.
    *
    * @throws boost::system::system_error Thrown on failure.
    *
    * @note If the timer has already expired when expires_at() is called, then
    * the handlers for asynchronous wait operations will:
    *
    * @li have already been invoked; or
    *
    * @li have been queued for invocation in the near future.
    *
    * These handlers can no longer be cancelled, and therefore are passed an
    * error code that indicates the successful completion of the wait operation.
    */
   std::size_t expires_at(const time_type& expiry_time)
   {
     boost::system::error_code ec;
     std::size_t s = this->service.expires_at(
         this->implementation, expiry_time, ec);
-    boost::asio::detail::throw_error(ec, "expires_at");
+    boost::asio::detail::throw_error(ec);
     return s;
   }
 
   /// Set the timer's expiry time as an absolute time.
   /**
    * This function sets the expiry time. Any pending asynchronous wait
    * operations will be cancelled. The handler for each cancelled operation will
    * be invoked with the boost::asio::error::operation_aborted error code.
    *
    * @param expiry_time The expiry time to be used for the timer.
    *
    * @param ec Set to indicate what error occurred, if any.
    *
    * @return The number of asynchronous operations that were cancelled.
    *
    * @note If the timer has already expired when expires_at() is called, then
    * the handlers for asynchronous wait operations will:
    *
    * @li have already been invoked; or
    *
    * @li have been queued for invocation in the near future.
    *
    * These handlers can no longer be cancelled, and therefore are passed an
    * error code that indicates the successful completion of the wait operation.
    */
   std::size_t expires_at(const time_type& expiry_time,
       boost::system::error_code& ec)
   {
     return this->service.expires_at(this->implementation, expiry_time, ec);
   }
 
   /// Get the timer's expiry time relative to now.
   /**
    * This function may be used to obtain the timer's current expiry time.
    * Whether the timer has expired or not does not affect this value.
    */
   duration_type expires_from_now() const
   {
     return this->service.expires_from_now(this->implementation);
   }
 
   /// Set the timer's expiry time relative to now.
   /**
    * This function sets the expiry time. Any pending asynchronous wait
    * operations will be cancelled. The handler for each cancelled operation will
    * be invoked with the boost::asio::error::operation_aborted error code.
    *
    * @param expiry_time The expiry time to be used for the timer.
    *
    * @return The number of asynchronous operations that were cancelled.
    *
    * @throws boost::system::system_error Thrown on failure.
    *
    * @note If the timer has already expired when expires_from_now() is called,
    * then the handlers for asynchronous wait operations will:
    *
    * @li have already been invoked; or
    *
    * @li have been queued for invocation in the near future.
    *
    * These handlers can no longer be cancelled, and therefore are passed an
    * error code that indicates the successful completion of the wait operation.
    */
   std::size_t expires_from_now(const duration_type& expiry_time)
   {
     boost::system::error_code ec;
     std::size_t s = this->service.expires_from_now(
         this->implementation, expiry_time, ec);
-    boost::asio::detail::throw_error(ec, "expires_from_now");
+    boost::asio::detail::throw_error(ec);
     return s;
   }
 
   /// Set the timer's expiry time relative to now.
   /**
    * This function sets the expiry time. Any pending asynchronous wait
    * operations will be cancelled. The handler for each cancelled operation will
    * be invoked with the boost::asio::error::operation_aborted error code.
    *
    * @param expiry_time The expiry time to be used for the timer.
    *
    * @param ec Set to indicate what error occurred, if any.
    *
    * @return The number of asynchronous operations that were cancelled.
    *
    * @note If the timer has already expired when expires_from_now() is called,
    * then the handlers for asynchronous wait operations will:
    *
    * @li have already been invoked; or
    *
    * @li have been queued for invocation in the near future.
    *
    * These handlers can no longer be cancelled, and therefore are passed an
    * error code that indicates the successful completion of the wait operation.
    */
   std::size_t expires_from_now(const duration_type& expiry_time,
       boost::system::error_code& ec)
   {
     return this->service.expires_from_now(
         this->implementation, expiry_time, ec);
   }
 
   /// Perform a blocking wait on the timer.
   /**
    * This function is used to wait for the timer to expire. This function
    * blocks and does not return until the timer has expired.
    *
    * @throws boost::system::system_error Thrown on failure.
    */
   void wait()
   {
     boost::system::error_code ec;
     this->service.wait(this->implementation, ec);
-    boost::asio::detail::throw_error(ec, "wait");
+    boost::asio::detail::throw_error(ec);
   }
 
   /// Perform a blocking wait on the timer.
   /**
    * This function is used to wait for the timer to expire. This function
    * blocks and does not return until the timer has expired.
    *
    * @param ec Set to indicate what error occurred, if any.
    */
   void wait(boost::system::error_code& ec)
   {
     this->service.wait(this->implementation, ec);
   }
 
   /// Start an asynchronous wait on the timer.
   /**
    * This function may be used to initiate an asynchronous wait against the
    * timer. It always returns immediately.
    *
    * For each call to async_wait(), the supplied handler will be called exactly
    * once. The handler will be called when:
    *
    * @li The timer has expired.
    *
    * @li The timer was cancelled, in which case the handler is passed the error
    * code boost::asio::error::operation_aborted.
    *
    * @param handler The handler to be called when the timer expires. Copies
    * will be made of the handler as required. The function signature of the
    * handler must be:
    * @code void handler(
    *   const boost::system::error_code& error // Result of operation.
    * ); @endcode
    * 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)
+  void async_wait(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,
-        BOOST_ASIO_MOVE_CAST(WaitHandler)(handler));
+    this->service.async_wait(this->implementation, handler);
   }
 };
 
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #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..8e137e7 100644
--- a/3rdParty/Boost/src/boost/asio/basic_io_object.hpp
+++ b/3rdParty/Boost/src/boost/asio/basic_io_object.hpp
@@ -1,242 +1,100 @@
 //
 // basic_io_object.hpp
 // ~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_BASIC_IO_OBJECT_HPP
 #define BOOST_ASIO_BASIC_IO_OBJECT_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/noncopyable.hpp>
 #include <boost/asio/io_service.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 
-#if defined(BOOST_ASIO_HAS_MOVE)
-namespace detail
-{
-  // Type trait used to determine whether a service supports move.
-  template <typename IoObjectService>
-  class service_has_move
-  {
-  private:
-    typedef IoObjectService service_type;
-    typedef typename service_type::implementation_type implementation_type;
-
-    template <typename T, typename U>
-    static auto eval(T* t, U* u) -> decltype(t->move_construct(*u, *u), char());
-    static char (&eval(...))[2];
-
-  public:
-    static const bool value =
-      sizeof(service_has_move::eval(
-        static_cast<service_type*>(0),
-        static_cast<implementation_type*>(0))) == 1;
-  };
-}
-#endif // defined(BOOST_ASIO_HAS_MOVE)
-
 /// Base class for all I/O objects.
-/**
- * @note All I/O objects are non-copyable. However, when using C++0x, certain
- * I/O objects do support move construction and move assignment.
- */
-#if !defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
 template <typename IoObjectService>
-#else
-template <typename IoObjectService,
-    bool Movable = detail::service_has_move<IoObjectService>::value>
-#endif
 class basic_io_object
+  : private noncopyable
 {
 public:
   /// The type of the service that will be used to provide I/O operations.
   typedef IoObjectService service_type;
 
   /// The underlying implementation type of I/O object.
   typedef typename service_type::implementation_type implementation_type;
 
+  /// (Deprecated: use get_io_service().) Get the io_service associated with
+  /// the object.
+  /**
+   * This function may be used to obtain the io_service object that the I/O
+   * object uses to dispatch handlers for asynchronous operations.
+   *
+   * @return A reference to the io_service object that the I/O object will use
+   * to dispatch handlers. Ownership is not transferred to the caller.
+   */
+  boost::asio::io_service& io_service()
+  {
+    return service.get_io_service();
+  }
+
   /// Get the io_service associated with the object.
   /**
    * This function may be used to obtain the io_service object that the I/O
    * object uses to dispatch handlers for asynchronous operations.
    *
    * @return A reference to the io_service object that the I/O object will use
    * to dispatch handlers. Ownership is not transferred to the caller.
    */
   boost::asio::io_service& get_io_service()
   {
     return service.get_io_service();
   }
 
 protected:
   /// Construct a basic_io_object.
   /**
    * Performs:
-   * @code get_service().construct(get_implementation()); @endcode
+   * @code service.construct(implementation); @endcode
    */
   explicit basic_io_object(boost::asio::io_service& io_service)
     : service(boost::asio::use_service<IoObjectService>(io_service))
   {
     service.construct(implementation);
   }
 
-#if defined(GENERATING_DOCUMENTATION)
-  /// Move-construct a basic_io_object.
-  /**
-   * Performs:
-   * @code get_service().move_construct(
-   *     get_implementation(), other.get_implementation()); @endcode
-   *
-   * @note Available only for services that support movability,
-   */
-  basic_io_object(basic_io_object&& other);
-
-  /// Move-assign a basic_io_object.
-  /**
-   * Performs:
-   * @code get_service().move_assign(get_implementation(),
-   *     other.get_service(), other.get_implementation()); @endcode
-   *
-   * @note Available only for services that support movability,
-   */
-  basic_io_object& operator=(basic_io_object&& other);
-#endif // defined(GENERATING_DOCUMENTATION)
-
   /// Protected destructor to prevent deletion through this type.
   /**
    * Performs:
-   * @code get_service().destroy(get_implementation()); @endcode
+   * @code service.destroy(implementation); @endcode
    */
   ~basic_io_object()
   {
     service.destroy(implementation);
   }
 
-  /// Get the service associated with the I/O object.
-  service_type& get_service()
-  {
-    return service;
-  }
-
-  /// Get the service associated with the I/O object.
-  const service_type& get_service() const
-  {
-    return service;
-  }
-
-  /// (Deprecated: Use get_service().) The service associated with the I/O
-  /// object.
-  /**
-   * @note Available only for services that do not support movability.
-   */
+  /// The service associated with the I/O object.
   service_type& service;
 
-  /// Get the underlying implementation of the I/O object.
-  implementation_type& get_implementation()
-  {
-    return implementation;
-  }
-
-  /// Get the underlying implementation of the I/O object.
-  const implementation_type& get_implementation() const
-  {
-    return implementation;
-  }
-
-  /// (Deprecated: Use get_implementation().) The underlying implementation of
-  /// the I/O object.
+  /// The underlying implementation of the I/O object.
   implementation_type implementation;
-
-private:
-  basic_io_object(const basic_io_object&);
-  basic_io_object& operator=(const basic_io_object&);
-};
-
-#if defined(BOOST_ASIO_HAS_MOVE)
-// Specialisation for movable objects.
-template <typename IoObjectService>
-class basic_io_object<IoObjectService, true>
-{
-public:
-  typedef IoObjectService service_type;
-  typedef typename service_type::implementation_type implementation_type;
-
-  boost::asio::io_service& get_io_service()
-  {
-    return service_->get_io_service();
-  }
-
-protected:
-  explicit basic_io_object(boost::asio::io_service& io_service)
-    : service_(&boost::asio::use_service<IoObjectService>(io_service))
-  {
-    service_->construct(implementation);
-  }
-
-  basic_io_object(basic_io_object&& other)
-    : service_(&other.get_service())
-  {
-    service_->move_construct(implementation, other.implementation);
-  }
-
-  ~basic_io_object()
-  {
-    service_->destroy(implementation);
-  }
-
-  basic_io_object& operator=(basic_io_object&& other)
-  {
-    service_->move_assign(implementation,
-        *other.service_, other.implementation);
-    service_ = other.service_;
-    return *this;
-  }
-
-  service_type& get_service()
-  {
-    return *service_;
-  }
-
-  const service_type& get_service() const
-  {
-    return *service_;
-  }
-
-  implementation_type& get_implementation()
-  {
-    return implementation;
-  }
-
-  const implementation_type& get_implementation() const
-  {
-    return implementation;
-  }
-
-  implementation_type implementation;
-
-private:
-  basic_io_object(const basic_io_object&);
-  void operator=(const basic_io_object&);
-
-  IoObjectService* service_;
 };
-#endif // defined(BOOST_ASIO_HAS_MOVE)
 
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // 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..0e58e7f 100644
--- a/3rdParty/Boost/src/boost/asio/basic_raw_socket.hpp
+++ b/3rdParty/Boost/src/boost/asio/basic_raw_socket.hpp
@@ -1,86 +1,81 @@
 //
 // basic_raw_socket.hpp
 // ~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_BASIC_RAW_SOCKET_HPP
 #define BOOST_ASIO_BASIC_RAW_SOCKET_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/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/raw_socket_service.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 
 /// Provides raw-oriented socket functionality.
 /**
  * The basic_raw_socket class template provides asynchronous and blocking
  * raw-oriented socket functionality.
  *
  * @par Thread Safety
  * @e Distinct @e objects: Safe.@n
  * @e Shared @e objects: Unsafe.
  */
 template <typename Protocol,
     typename RawSocketService = raw_socket_service<Protocol> >
 class basic_raw_socket
   : public basic_socket<Protocol, RawSocketService>
 {
 public:
-  /// (Deprecated: Use native_handle_type.) The native representation of a
-  /// socket.
-  typedef typename RawSocketService::native_handle_type native_type;
-
   /// The native representation of a socket.
-  typedef typename RawSocketService::native_handle_type native_handle_type;
+  typedef typename RawSocketService::native_type native_type;
 
   /// The protocol type.
   typedef Protocol protocol_type;
 
   /// The endpoint type.
   typedef typename Protocol::endpoint endpoint_type;
 
   /// Construct a basic_raw_socket without opening it.
   /**
    * This constructor creates a raw socket without opening it. The open()
    * function must be called before data can be sent or received on the socket.
    *
    * @param io_service The io_service object that the raw socket will use
    * to dispatch handlers for any asynchronous operations performed on the
    * socket.
    */
   explicit basic_raw_socket(boost::asio::io_service& io_service)
     : basic_socket<Protocol, RawSocketService>(io_service)
   {
   }
 
   /// Construct and open a basic_raw_socket.
   /**
    * This constructor creates and opens a raw socket.
    *
    * @param io_service The io_service object that the raw socket will use
    * to dispatch handlers for any asynchronous operations performed on the
    * socket.
    *
    * @param protocol An object specifying protocol parameters to be used.
    *
    * @throws boost::system::system_error Thrown on failure.
    */
   basic_raw_socket(boost::asio::io_service& io_service,
       const protocol_type& protocol)
@@ -94,789 +89,709 @@ public:
    * This constructor creates a raw socket and automatically opens it bound
    * to the specified endpoint on the local machine. The protocol used is the
    * protocol associated with the given endpoint.
    *
    * @param io_service The io_service object that the raw socket will use
    * to dispatch handlers for any asynchronous operations performed on the
    * socket.
    *
    * @param endpoint An endpoint on the local machine to which the raw
    * socket will be bound.
    *
    * @throws boost::system::system_error Thrown on failure.
    */
   basic_raw_socket(boost::asio::io_service& io_service,
       const endpoint_type& endpoint)
     : basic_socket<Protocol, RawSocketService>(io_service, endpoint)
   {
   }
 
   /// Construct a basic_raw_socket on an existing native socket.
   /**
    * This constructor creates a raw socket object to hold an existing
    * native socket.
    *
    * @param io_service The io_service object that the raw socket will use
    * to dispatch handlers for any asynchronous operations performed on the
    * socket.
    *
    * @param protocol An object specifying protocol parameters to be used.
    *
    * @param native_socket The new underlying socket implementation.
    *
    * @throws boost::system::system_error Thrown on failure.
    */
   basic_raw_socket(boost::asio::io_service& io_service,
-      const protocol_type& protocol, const native_handle_type& native_socket)
+      const protocol_type& protocol, const native_type& native_socket)
     : basic_socket<Protocol, RawSocketService>(
         io_service, protocol, native_socket)
   {
   }
 
-#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
-  /// Move-construct a basic_raw_socket from another.
-  /**
-   * 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.
-   */
-  basic_raw_socket(basic_raw_socket&& other)
-    : basic_socket<Protocol, RawSocketService>(
-        BOOST_ASIO_MOVE_CAST(basic_raw_socket)(other))
-  {
-  }
-
-  /// Move-assign a basic_raw_socket from another.
-  /**
-   * 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.
-   */
-  basic_raw_socket& operator=(basic_raw_socket&& other)
-  {
-    basic_socket<Protocol, RawSocketService>::operator=(
-        BOOST_ASIO_MOVE_CAST(basic_raw_socket)(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.
    *
    * @param buffers One ore more data buffers to be sent on the socket.
    *
    * @returns The number of bytes sent.
    *
    * @throws boost::system::system_error Thrown on failure.
    *
    * @note The send operation can only be used with a connected socket. Use
    * the send_to function to send data on an unconnected raw socket.
    *
    * @par Example
    * To send a single data buffer use the @ref buffer function as follows:
    * @code socket.send(boost::asio::buffer(data, size)); @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>
   std::size_t send(const ConstBufferSequence& buffers)
   {
     boost::system::error_code ec;
-    std::size_t s = this->get_service().send(
-        this->get_implementation(), buffers, 0, ec);
-    boost::asio::detail::throw_error(ec, "send");
+    std::size_t s = this->service.send(this->implementation, buffers, 0, ec);
+    boost::asio::detail::throw_error(ec);
     return s;
   }
 
   /// 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.
    *
    * @param buffers One ore more data buffers to be sent on the socket.
    *
    * @param flags Flags specifying how the send call is to be made.
    *
    * @returns The number of bytes sent.
    *
    * @throws boost::system::system_error Thrown on failure.
    *
    * @note The send operation can only be used with a connected socket. Use
    * the send_to function to send data on an unconnected raw socket.
    */
   template <typename ConstBufferSequence>
   std::size_t send(const ConstBufferSequence& buffers,
       socket_base::message_flags flags)
   {
     boost::system::error_code ec;
-    std::size_t s = this->get_service().send(
-        this->get_implementation(), buffers, flags, ec);
-    boost::asio::detail::throw_error(ec, "send");
+    std::size_t s = this->service.send(
+        this->implementation, buffers, flags, ec);
+    boost::asio::detail::throw_error(ec);
     return s;
   }
 
   /// 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.
    *
    * @param buffers One or more data buffers to be sent on the socket.
    *
    * @param flags Flags specifying how the send call is to be made.
    *
    * @param ec Set to indicate what error occurred, if any.
    *
    * @returns The number of bytes sent.
    *
    * @note The send operation can only be used with a connected socket. Use
    * the send_to function to send data on an unconnected raw socket.
    */
   template <typename ConstBufferSequence>
   std::size_t send(const ConstBufferSequence& buffers,
       socket_base::message_flags flags, boost::system::error_code& ec)
   {
-    return this->get_service().send(
-        this->get_implementation(), buffers, flags, ec);
+    return this->service.send(this->implementation, buffers, flags, ec);
   }
 
   /// Start an asynchronous send 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.
    *
    * @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.
    *
    * @param handler The handler to be called when the send operation completes.
    * Copies will be made of the handler as required. The function signature of
    * the handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
    *   std::size_t bytes_transferred           // Number of bytes sent.
    * ); @endcode
    * 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().
    *
    * @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.
    *
    * @par Example
    * To send a single data buffer use the @ref buffer function as follows:
    * @code
    * socket.async_send(boost::asio::buffer(data, size), handler);
    * @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_MOVE_ARG(WriteHandler) handler)
+  void async_send(const ConstBufferSequence& buffers, 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, BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
+    this->service.async_send(this->implementation, buffers, 0, handler);
   }
 
   /// Start an asynchronous send 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.
    *
    * @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.
    *
    * @param flags Flags specifying how the send call is to be made.
    *
    * @param handler The handler to be called when the send operation completes.
    * Copies will be made of the handler as required. The function signature of
    * the handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
    *   std::size_t bytes_transferred           // Number of bytes sent.
    * ); @endcode
    * 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().
    *
    * @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,
-      socket_base::message_flags flags,
-      BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
+      socket_base::message_flags flags, 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, BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
+    this->service.async_send(this->implementation, buffers, flags, handler);
   }
 
   /// Send raw data to the specified endpoint.
   /**
    * This function is used to send raw data to the specified remote endpoint.
    * The function call will block until the data has been sent successfully or
    * an error occurs.
    *
    * @param buffers One or more data buffers to be sent to the remote endpoint.
    *
    * @param destination The remote endpoint to which the data will be sent.
    *
    * @returns The number of bytes sent.
    *
    * @throws boost::system::system_error Thrown on failure.
    *
    * @par Example
    * To send a single data buffer use the @ref buffer function as follows:
    * @code
    * boost::asio::ip::udp::endpoint destination(
    *     boost::asio::ip::address::from_string("1.2.3.4"), 12345);
    * socket.send_to(boost::asio::buffer(data, size), destination);
    * @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>
   std::size_t send_to(const ConstBufferSequence& buffers,
       const endpoint_type& destination)
   {
     boost::system::error_code ec;
-    std::size_t s = this->get_service().send_to(
-        this->get_implementation(), buffers, destination, 0, ec);
-    boost::asio::detail::throw_error(ec, "send_to");
+    std::size_t s = this->service.send_to(
+        this->implementation, buffers, destination, 0, ec);
+    boost::asio::detail::throw_error(ec);
     return s;
   }
 
   /// Send raw data to the specified endpoint.
   /**
    * This function is used to send raw data to the specified remote endpoint.
    * The function call will block until the data has been sent successfully or
    * an error occurs.
    *
    * @param buffers One or more data buffers to be sent to the remote endpoint.
    *
    * @param destination The remote endpoint to which the data will be sent.
    *
    * @param flags Flags specifying how the send call is to be made.
    *
    * @returns The number of bytes sent.
    *
    * @throws boost::system::system_error Thrown on failure.
    */
   template <typename ConstBufferSequence>
   std::size_t send_to(const ConstBufferSequence& buffers,
       const endpoint_type& destination, socket_base::message_flags flags)
   {
     boost::system::error_code ec;
-    std::size_t s = this->get_service().send_to(
-        this->get_implementation(), buffers, destination, flags, ec);
-    boost::asio::detail::throw_error(ec, "send_to");
+    std::size_t s = this->service.send_to(
+        this->implementation, buffers, destination, flags, ec);
+    boost::asio::detail::throw_error(ec);
     return s;
   }
 
   /// Send raw data to the specified endpoint.
   /**
    * This function is used to send raw data to the specified remote endpoint.
    * The function call will block until the data has been sent successfully or
    * an error occurs.
    *
    * @param buffers One or more data buffers to be sent to the remote endpoint.
    *
    * @param destination The remote endpoint to which the data will be sent.
    *
    * @param flags Flags specifying how the send call is to be made.
    *
    * @param ec Set to indicate what error occurred, if any.
    *
    * @returns The number of bytes sent.
    */
   template <typename ConstBufferSequence>
   std::size_t send_to(const ConstBufferSequence& buffers,
       const endpoint_type& destination, socket_base::message_flags flags,
       boost::system::error_code& ec)
   {
-    return this->get_service().send_to(this->get_implementation(),
+    return this->service.send_to(this->implementation,
         buffers, destination, flags, ec);
   }
 
   /// Start an asynchronous send.
   /**
    * This function is used to asynchronously send raw data to the specified
    * remote endpoint. The function call always returns immediately.
    *
    * @param buffers One or more data buffers to be sent to the remote endpoint.
    * 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.
    *
    * @param destination The remote endpoint to which the data will be sent.
    * Copies will be made of the endpoint as required.
    *
    * @param handler The handler to be called when the send operation completes.
    * Copies will be made of the handler as required. The function signature of
    * the handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
    *   std::size_t bytes_transferred           // Number of bytes sent.
    * ); @endcode
    * 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().
    *
    * @par Example
    * To send a single data buffer use the @ref buffer function as follows:
    * @code
    * boost::asio::ip::udp::endpoint destination(
    *     boost::asio::ip::address::from_string("1.2.3.4"), 12345);
    * socket.async_send_to(
    *     boost::asio::buffer(data, size), destination, handler);
    * @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,
-      const endpoint_type& destination,
-      BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
+      const endpoint_type& destination, 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));
+    this->service.async_send_to(this->implementation, buffers, destination, 0,
+        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.
    *
    * @param buffers One or more data buffers to be sent to the remote endpoint.
    * 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.
    *
    * @param flags Flags specifying how the send call is to be made.
    *
    * @param destination The remote endpoint to which the data will be sent.
    * Copies will be made of the endpoint as required.
    *
    * @param handler The handler to be called when the send operation completes.
    * Copies will be made of the handler as required. The function signature of
    * the handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
    *   std::size_t bytes_transferred           // Number of bytes sent.
    * ); @endcode
    * 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,
       const endpoint_type& destination, socket_base::message_flags flags,
-      BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
+      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));
+    this->service.async_send_to(this->implementation, buffers, destination,
+        flags, 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
    * occurs.
    *
    * @param buffers One or more buffers into which the data will be received.
    *
    * @returns The number of bytes received.
    *
    * @throws boost::system::system_error Thrown on failure.
    *
    * @note The receive operation can only be used with a connected socket. Use
    * the receive_from function to receive data on an unconnected raw
    * socket.
    *
    * @par Example
    * To receive into a single data buffer use the @ref buffer function as
    * follows:
    * @code socket.receive(boost::asio::buffer(data, size)); @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>
   std::size_t receive(const MutableBufferSequence& buffers)
   {
     boost::system::error_code ec;
-    std::size_t s = this->get_service().receive(
-        this->get_implementation(), buffers, 0, ec);
-    boost::asio::detail::throw_error(ec, "receive");
+    std::size_t s = this->service.receive(
+        this->implementation, buffers, 0, ec);
+    boost::asio::detail::throw_error(ec);
     return s;
   }
 
   /// 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
    * occurs.
    *
    * @param buffers One or more buffers into which the data will be received.
    *
    * @param flags Flags specifying how the receive call is to be made.
    *
    * @returns The number of bytes received.
    *
    * @throws boost::system::system_error Thrown on failure.
    *
    * @note The receive operation can only be used with a connected socket. Use
    * the receive_from function to receive data on an unconnected raw
    * socket.
    */
   template <typename MutableBufferSequence>
   std::size_t receive(const MutableBufferSequence& buffers,
       socket_base::message_flags flags)
   {
     boost::system::error_code ec;
-    std::size_t s = this->get_service().receive(
-        this->get_implementation(), buffers, flags, ec);
-    boost::asio::detail::throw_error(ec, "receive");
+    std::size_t s = this->service.receive(
+        this->implementation, buffers, flags, ec);
+    boost::asio::detail::throw_error(ec);
     return s;
   }
 
   /// 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
    * occurs.
    *
    * @param buffers One or more buffers into which the data will be received.
    *
    * @param flags Flags specifying how the receive call is to be made.
    *
    * @param ec Set to indicate what error occurred, if any.
    *
    * @returns The number of bytes received.
    *
    * @note The receive operation can only be used with a connected socket. Use
    * the receive_from function to receive data on an unconnected raw
    * socket.
    */
   template <typename MutableBufferSequence>
   std::size_t receive(const MutableBufferSequence& buffers,
       socket_base::message_flags flags, boost::system::error_code& ec)
   {
-    return this->get_service().receive(
-        this->get_implementation(), buffers, flags, ec);
+    return this->service.receive(this->implementation, buffers, flags, ec);
   }
 
   /// Start an asynchronous receive on a connected socket.
   /**
    * This function is used to asynchronously receive data from the raw
    * socket. The function call always returns immediately.
    *
    * @param buffers One or more buffers into which the data will be received.
    * 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.
    *
    * @param handler The handler to be called when the receive operation
    * completes. Copies will be made of the handler as required. The function
    * signature of the handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
    *   std::size_t bytes_transferred           // Number of bytes received.
    * ); @endcode
    * 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().
    *
    * @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.
    *
    * @par Example
    * To receive into a single data buffer use the @ref buffer function as
    * follows:
    * @code
    * socket.async_receive(boost::asio::buffer(data, size), 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(const MutableBufferSequence& buffers,
-      BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+  void async_receive(const MutableBufferSequence& buffers, 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, BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
+    this->service.async_receive(this->implementation, buffers, 0, handler);
   }
 
   /// Start an asynchronous receive on a connected socket.
   /**
    * This function is used to asynchronously receive data from the raw
    * socket. The function call always returns immediately.
    *
    * @param buffers One or more buffers into which the data will be received.
    * 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.
    *
    * @param flags Flags specifying how the receive call is to be made.
    *
    * @param handler The handler to be called when the receive operation
    * completes. Copies will be made of the handler as required. The function
    * signature of the handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
    *   std::size_t bytes_transferred           // Number of bytes received.
    * ); @endcode
    * 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().
    *
    * @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,
-      socket_base::message_flags flags,
-      BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+      socket_base::message_flags flags, 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, flags, BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
+    this->service.async_receive(this->implementation, buffers, flags, handler);
   }
 
   /// Receive raw data with the endpoint of the sender.
   /**
    * This function is used to receive raw data. The function call will block
    * until data has been received successfully or an error occurs.
    *
    * @param buffers One or more buffers into which the data will be received.
    *
    * @param sender_endpoint An endpoint object that receives the endpoint of
    * the remote sender of the data.
    *
    * @returns The number of bytes received.
    *
    * @throws boost::system::system_error Thrown on failure.
    *
    * @par Example
    * To receive into a single data buffer use the @ref buffer function as
    * follows:
    * @code
    * boost::asio::ip::udp::endpoint sender_endpoint;
    * socket.receive_from(
    *     boost::asio::buffer(data, size), sender_endpoint);
    * @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>
   std::size_t receive_from(const MutableBufferSequence& buffers,
       endpoint_type& sender_endpoint)
   {
     boost::system::error_code ec;
-    std::size_t s = this->get_service().receive_from(
-        this->get_implementation(), buffers, sender_endpoint, 0, ec);
-    boost::asio::detail::throw_error(ec, "receive_from");
+    std::size_t s = this->service.receive_from(
+        this->implementation, buffers, sender_endpoint, 0, ec);
+    boost::asio::detail::throw_error(ec);
     return s;
   }
   
   /// Receive raw data with the endpoint of the sender.
   /**
    * This function is used to receive raw data. The function call will block
    * until data has been received successfully or an error occurs.
    *
    * @param buffers One or more buffers into which the data will be received.
    *
    * @param sender_endpoint An endpoint object that receives the endpoint of
    * the remote sender of the data.
    *
    * @param flags Flags specifying how the receive call is to be made.
    *
    * @returns The number of bytes received.
    *
    * @throws boost::system::system_error Thrown on failure.
    */
   template <typename MutableBufferSequence>
   std::size_t receive_from(const MutableBufferSequence& buffers,
       endpoint_type& sender_endpoint, socket_base::message_flags flags)
   {
     boost::system::error_code ec;
-    std::size_t s = this->get_service().receive_from(
-        this->get_implementation(), buffers, sender_endpoint, flags, ec);
-    boost::asio::detail::throw_error(ec, "receive_from");
+    std::size_t s = this->service.receive_from(
+        this->implementation, buffers, sender_endpoint, flags, ec);
+    boost::asio::detail::throw_error(ec);
     return s;
   }
   
   /// Receive raw data with the endpoint of the sender.
   /**
    * This function is used to receive raw data. The function call will block
    * until data has been received successfully or an error occurs.
    *
    * @param buffers One or more buffers into which the data will be received.
    *
    * @param sender_endpoint An endpoint object that receives the endpoint of
    * the remote sender of the data.
    *
    * @param flags Flags specifying how the receive call is to be made.
    *
    * @param ec Set to indicate what error occurred, if any.
    *
    * @returns The number of bytes received.
    */
   template <typename MutableBufferSequence>
   std::size_t receive_from(const MutableBufferSequence& buffers,
       endpoint_type& sender_endpoint, socket_base::message_flags flags,
       boost::system::error_code& ec)
   {
-    return this->get_service().receive_from(this->get_implementation(),
-        buffers, sender_endpoint, flags, ec);
+    return this->service.receive_from(this->implementation, buffers,
+        sender_endpoint, flags, ec);
   }
 
   /// Start an asynchronous receive.
   /**
    * This function is used to asynchronously receive raw data. The function
    * call always returns immediately.
    *
    * @param buffers One or more buffers into which the data will be received.
    * 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.
    *
    * @param sender_endpoint An endpoint object that receives the endpoint of
    * the remote sender of the data. Ownership of the sender_endpoint object
    * is retained by the caller, which must guarantee that it is valid until the
    * handler is called.
    *
    * @param handler The handler to be called when the receive operation
    * completes. Copies will be made of the handler as required. The function
    * signature of the handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
    *   std::size_t bytes_transferred           // Number of bytes received.
    * ); @endcode
    * 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().
    *
    * @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
    * 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,
-      endpoint_type& sender_endpoint,
-      BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+      endpoint_type& sender_endpoint, 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));
+    this->service.async_receive_from(this->implementation, buffers,
+        sender_endpoint, 0, handler);
   }
 
   /// Start an asynchronous receive.
   /**
    * This function is used to asynchronously receive raw data. The function
    * call always returns immediately.
    *
    * @param buffers One or more buffers into which the data will be received.
    * 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.
    *
    * @param sender_endpoint An endpoint object that receives the endpoint of
    * the remote sender of the data. Ownership of the sender_endpoint object
    * is retained by the caller, which must guarantee that it is valid until the
    * handler is called.
    *
    * @param flags Flags specifying how the receive call is to be made.
    *
    * @param handler The handler to be called when the receive operation
    * completes. Copies will be made of the handler as required. The function
    * signature of the handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
    *   std::size_t bytes_transferred           // Number of bytes received.
    * ); @endcode
    * 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,
       endpoint_type& sender_endpoint, socket_base::message_flags flags,
-      BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+      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));
+    this->service.async_receive_from(this->implementation, buffers,
+        sender_endpoint, flags, handler);
   }
 };
 
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // BOOST_ASIO_BASIC_RAW_SOCKET_HPP
diff --git a/3rdParty/Boost/src/boost/asio/basic_seq_packet_socket.hpp b/3rdParty/Boost/src/boost/asio/basic_seq_packet_socket.hpp
deleted file mode 100644
index a638c71..0000000
--- a/3rdParty/Boost/src/boost/asio/basic_seq_packet_socket.hpp
+++ /dev/null
@@ -1,514 +0,0 @@
-//
-// basic_seq_packet_socket.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_BASIC_SEQ_PACKET_SOCKET_HPP
-#define BOOST_ASIO_BASIC_SEQ_PACKET_SOCKET_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/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/seq_packet_socket_service.hpp>
-
-#include <boost/asio/detail/push_options.hpp>
-
-namespace boost {
-namespace asio {
-
-/// Provides sequenced packet socket functionality.
-/**
- * The basic_seq_packet_socket class template provides asynchronous and blocking
- * sequenced packet socket functionality.
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Unsafe.
- */
-template <typename Protocol,
-    typename SeqPacketSocketService = seq_packet_socket_service<Protocol> >
-class basic_seq_packet_socket
-  : public basic_socket<Protocol, SeqPacketSocketService>
-{
-public:
-  /// (Deprecated: Use native_handle_type.) The native representation of a
-  /// socket.
-  typedef typename SeqPacketSocketService::native_handle_type native_type;
-
-  /// The native representation of a socket.
-  typedef typename SeqPacketSocketService::native_handle_type
-    native_handle_type;
-
-  /// The protocol type.
-  typedef Protocol protocol_type;
-
-  /// The endpoint type.
-  typedef typename Protocol::endpoint endpoint_type;
-
-  /// Construct a basic_seq_packet_socket without opening it.
-  /**
-   * This constructor creates a sequenced packet socket without opening it. The
-   * socket needs to be opened and then connected or accepted before data can
-   * be sent or received on it.
-   *
-   * @param io_service The io_service object that the sequenced packet socket
-   * will use to dispatch handlers for any asynchronous operations performed on
-   * the socket.
-   */
-  explicit basic_seq_packet_socket(boost::asio::io_service& io_service)
-    : basic_socket<Protocol, SeqPacketSocketService>(io_service)
-  {
-  }
-
-  /// Construct and open a basic_seq_packet_socket.
-  /**
-   * This constructor creates and opens a sequenced_packet socket. The socket
-   * needs to be connected or accepted before data can be sent or received on
-   * it.
-   *
-   * @param io_service The io_service object that the sequenced packet socket
-   * will use to dispatch handlers for any asynchronous operations performed on
-   * the socket.
-   *
-   * @param protocol An object specifying protocol parameters to be used.
-   *
-   * @throws boost::system::system_error Thrown on failure.
-   */
-  basic_seq_packet_socket(boost::asio::io_service& io_service,
-      const protocol_type& protocol)
-    : basic_socket<Protocol, SeqPacketSocketService>(io_service, protocol)
-  {
-  }
-
-  /// Construct a basic_seq_packet_socket, opening it and binding it to the
-  /// given local endpoint.
-  /**
-   * This constructor creates a sequenced packet socket and automatically opens
-   * it bound to the specified endpoint on the local machine. The protocol used
-   * is the protocol associated with the given endpoint.
-   *
-   * @param io_service The io_service object that the sequenced packet socket
-   * will use to dispatch handlers for any asynchronous operations performed on
-   * the socket.
-   *
-   * @param endpoint An endpoint on the local machine to which the sequenced
-   * packet socket will be bound.
-   *
-   * @throws boost::system::system_error Thrown on failure.
-   */
-  basic_seq_packet_socket(boost::asio::io_service& io_service,
-      const endpoint_type& endpoint)
-    : basic_socket<Protocol, SeqPacketSocketService>(io_service, endpoint)
-  {
-  }
-
-  /// Construct a basic_seq_packet_socket on an existing native socket.
-  /**
-   * This constructor creates a sequenced packet socket object to hold an
-   * existing native socket.
-   *
-   * @param io_service The io_service object that the sequenced packet socket
-   * will use to dispatch handlers for any asynchronous operations performed on
-   * the socket.
-   *
-   * @param protocol An object specifying protocol parameters to be used.
-   *
-   * @param native_socket The new underlying socket implementation.
-   *
-   * @throws boost::system::system_error Thrown on failure.
-   */
-  basic_seq_packet_socket(boost::asio::io_service& io_service,
-      const protocol_type& protocol, const native_handle_type& native_socket)
-    : basic_socket<Protocol, SeqPacketSocketService>(
-        io_service, protocol, native_socket)
-  {
-  }
-
-#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
-  /// Move-construct a basic_seq_packet_socket from another.
-  /**
-   * 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.
-   */
-  basic_seq_packet_socket(basic_seq_packet_socket&& other)
-    : basic_socket<Protocol, SeqPacketSocketService>(
-        BOOST_ASIO_MOVE_CAST(basic_seq_packet_socket)(other))
-  {
-  }
-
-  /// Move-assign a basic_seq_packet_socket from another.
-  /**
-   * 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.
-   */
-  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;
-  }
-#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
-   * until error occurs.
-   *
-   * @param buffers One or more data buffers to be sent on the socket.
-   *
-   * @param flags Flags specifying how the send call is to be made.
-   *
-   * @returns The number of bytes sent.
-   *
-   * @throws boost::system::system_error Thrown on failure.
-   *
-   * @par Example
-   * To send a single data buffer use the @ref buffer function as follows:
-   * @code
-   * socket.send(boost::asio::buffer(data, size), 0);
-   * @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>
-  std::size_t send(const ConstBufferSequence& buffers,
-      socket_base::message_flags flags)
-  {
-    boost::system::error_code ec;
-    std::size_t s = this->get_service().send(
-        this->get_implementation(), buffers, flags, ec);
-    boost::asio::detail::throw_error(ec, "send");
-    return s;
-  }
-
-  /// Send some data on the socket.
-  /**
-   * This function is used to send data on the sequenced packet socket. The
-   * function call will block the data has been sent successfully, or an until
-   * error occurs.
-   *
-   * @param buffers One or more data buffers to be sent on the socket.
-   *
-   * @param flags Flags specifying how the send call is to be made.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @returns The number of bytes sent. Returns 0 if an error occurred.
-   *
-   * @note The send operation may not transmit all of the data to the peer.
-   * Consider using the @ref write function if you need to ensure that all data
-   * is written before the blocking operation completes.
-   */
-  template <typename ConstBufferSequence>
-  std::size_t send(const ConstBufferSequence& buffers,
-      socket_base::message_flags flags, boost::system::error_code& ec)
-  {
-    return this->get_service().send(
-        this->get_implementation(), buffers, flags, ec);
-  }
-
-  /// Start an asynchronous send.
-  /**
-   * This function is used to asynchronously send data on the sequenced packet
-   * 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.
-   *
-   * @param flags Flags specifying how the send call is to be made.
-   *
-   * @param handler The handler to be called when the send operation completes.
-   * Copies will be made of the handler as required. The function signature of
-   * the handler must be:
-   * @code void handler(
-   *   const boost::system::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes sent.
-   * ); @endcode
-   * 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().
-   *
-   * @par Example
-   * To send a single data buffer use the @ref buffer function as follows:
-   * @code
-   * socket.async_send(boost::asio::buffer(data, size), 0, handler);
-   * @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,
-      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, 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
-   * function call will block until data has been received successfully, or
-   * until an error occurs.
-   *
-   * @param buffers One or more buffers into which the data will be received.
-   *
-   * @param out_flags After the receive call completes, contains flags
-   * associated with the received data. For example, if the
-   * socket_base::message_end_of_record bit is set then the received data marks
-   * the end of a record.
-   *
-   * @returns The number of bytes received.
-   *
-   * @throws boost::system::system_error Thrown on failure. An error code of
-   * boost::asio::error::eof indicates that the connection was closed by the
-   * peer.
-   *
-   * @par Example
-   * To receive into a single data buffer use the @ref buffer function as
-   * follows:
-   * @code
-   * socket.receive(boost::asio::buffer(data, size), out_flags);
-   * @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>
-  std::size_t receive(const MutableBufferSequence& buffers,
-      socket_base::message_flags& out_flags)
-  {
-    boost::system::error_code ec;
-    std::size_t s = this->get_service().receive(
-        this->get_implementation(), buffers, 0, out_flags, ec);
-    boost::asio::detail::throw_error(ec, "receive");
-    return s;
-  }
-
-  /// Receive some data on the socket.
-  /**
-   * This function is used to receive data on the sequenced packet socket. The
-   * function call will block until data has been received successfully, or
-   * until an error occurs.
-   *
-   * @param buffers One or more buffers into which the data will be received.
-   *
-   * @param in_flags Flags specifying how the receive call is to be made.
-   *
-   * @param out_flags After the receive call completes, contains flags
-   * associated with the received data. For example, if the
-   * socket_base::message_end_of_record bit is set then the received data marks
-   * the end of a record.
-   *
-   * @returns The number of bytes received.
-   *
-   * @throws boost::system::system_error Thrown on failure. An error code of
-   * boost::asio::error::eof indicates that the connection was closed by the
-   * peer.
-   *
-   * @note The receive operation may not receive all of the requested number of
-   * bytes. Consider using the @ref read function if you need to ensure that the
-   * requested amount of data is read before the blocking operation completes.
-   *
-   * @par Example
-   * To receive into a single data buffer use the @ref buffer function as
-   * follows:
-   * @code
-   * socket.receive(boost::asio::buffer(data, size), 0, out_flags);
-   * @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>
-  std::size_t receive(const MutableBufferSequence& buffers,
-      socket_base::message_flags in_flags,
-      socket_base::message_flags& out_flags)
-  {
-    boost::system::error_code ec;
-    std::size_t s = this->get_service().receive(
-        this->get_implementation(), buffers, in_flags, out_flags, ec);
-    boost::asio::detail::throw_error(ec, "receive");
-    return s;
-  }
-
-  /// Receive some data on a connected socket.
-  /**
-   * This function is used to receive data on the sequenced packet socket. The
-   * function call will block until data has been received successfully, or
-   * until an error occurs.
-   *
-   * @param buffers One or more buffers into which the data will be received.
-   *
-   * @param in_flags Flags specifying how the receive call is to be made.
-   *
-   * @param out_flags After the receive call completes, contains flags
-   * associated with the received data. For example, if the
-   * socket_base::message_end_of_record bit is set then the received data marks
-   * the end of a record.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @returns The number of bytes received. Returns 0 if an error occurred.
-   *
-   * @note The receive operation may not receive all of the requested number of
-   * bytes. Consider using the @ref read 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 receive(const MutableBufferSequence& buffers,
-      socket_base::message_flags in_flags,
-      socket_base::message_flags& out_flags, boost::system::error_code& ec)
-  {
-    return this->get_service().receive(this->get_implementation(),
-        buffers, in_flags, out_flags, ec);
-  }
-
-  /// Start an asynchronous receive.
-  /**
-   * This function is used to asynchronously receive data from the sequenced
-   * packet socket. The function call always returns immediately.
-   *
-   * @param buffers One or more buffers into which the data will be received.
-   * 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.
-   *
-   * @param out_flags Once the asynchronous operation completes, contains flags
-   * associated with the received data. For example, if the
-   * socket_base::message_end_of_record bit is set then the received data marks
-   * the end of a record. The caller must guarantee that the referenced
-   * variable remains valid until the handler is called.
-   *
-   * @param handler The handler to be called when the receive operation
-   * completes. Copies will be made of the handler as required. The function
-   * signature of the handler must be:
-   * @code void handler(
-   *   const boost::system::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes received.
-   * ); @endcode
-   * 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().
-   *
-   * @par Example
-   * To receive into a single data buffer use the @ref buffer function as
-   * follows:
-   * @code
-   * socket.async_receive(boost::asio::buffer(data, size), out_flags, 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(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));
-  }
-
-  /// Start an asynchronous receive.
-  /**
-   * This function is used to asynchronously receive data from the sequenced
-   * data socket. The function call always returns immediately.
-   *
-   * @param buffers One or more buffers into which the data will be received.
-   * 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.
-   *
-   * @param in_flags Flags specifying how the receive call is to be made.
-   *
-   * @param out_flags Once the asynchronous operation completes, contains flags
-   * associated with the received data. For example, if the
-   * socket_base::message_end_of_record bit is set then the received data marks
-   * the end of a record. The caller must guarantee that the referenced
-   * variable remains valid until the handler is called.
-   *
-   * @param handler The handler to be called when the receive operation
-   * completes. Copies will be made of the handler as required. The function
-   * signature of the handler must be:
-   * @code void handler(
-   *   const boost::system::error_code& error, // Result of operation.
-   *   std::size_t bytes_transferred           // Number of bytes received.
-   * ); @endcode
-   * 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().
-   *
-   * @par Example
-   * To receive into a single data buffer use the @ref buffer function as
-   * follows:
-   * @code
-   * socket.async_receive(
-   *     boost::asio::buffer(data, size),
-   *     0, out_flags, 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(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));
-  }
-};
-
-} // namespace asio
-} // namespace boost
-
-#include <boost/asio/detail/pop_options.hpp>
-
-#endif // BOOST_ASIO_BASIC_SEQ_PACKET_SOCKET_HPP
diff --git a/3rdParty/Boost/src/boost/asio/basic_serial_port.hpp b/3rdParty/Boost/src/boost/asio/basic_serial_port.hpp
index 31ee955..744fd3b 100644
--- a/3rdParty/Boost/src/boost/asio/basic_serial_port.hpp
+++ b/3rdParty/Boost/src/boost/asio/basic_serial_port.hpp
@@ -1,693 +1,622 @@
 //
 // basic_serial_port.hpp
 // ~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2011 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)
 //
 
 #ifndef BOOST_ASIO_BASIC_SERIAL_PORT_HPP
 #define BOOST_ASIO_BASIC_SERIAL_PORT_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_SERIAL_PORT) \
   || defined(GENERATING_DOCUMENTATION)
 
 #include <string>
 #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/error.hpp>
 #include <boost/asio/serial_port_base.hpp>
 #include <boost/asio/serial_port_service.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 
 /// Provides serial port functionality.
 /**
  * The basic_serial_port class template provides functionality that is common
  * to all serial ports.
  *
  * @par Thread Safety
  * @e Distinct @e objects: Safe.@n
  * @e Shared @e objects: Unsafe.
  */
 template <typename SerialPortService = serial_port_service>
 class basic_serial_port
   : public basic_io_object<SerialPortService>,
     public serial_port_base
 {
 public:
-  /// (Deprecated: Use native_handle_type.) The native representation of a
-  /// serial port.
-  typedef typename SerialPortService::native_handle_type native_type;
-
   /// The native representation of a serial port.
-  typedef typename SerialPortService::native_handle_type native_handle_type;
+  typedef typename SerialPortService::native_type native_type;
 
   /// A basic_serial_port is always the lowest layer.
   typedef basic_serial_port<SerialPortService> lowest_layer_type;
 
   /// Construct a basic_serial_port without opening it.
   /**
    * This constructor creates a serial port without opening it.
    *
    * @param io_service The io_service object that the serial port will use to
    * dispatch handlers for any asynchronous operations performed on the port.
    */
   explicit basic_serial_port(boost::asio::io_service& io_service)
     : basic_io_object<SerialPortService>(io_service)
   {
   }
 
   /// Construct and open a basic_serial_port.
   /**
    * This constructor creates and opens a serial port for the specified device
    * name.
    *
    * @param io_service The io_service object that the serial port will use to
    * dispatch handlers for any asynchronous operations performed on the port.
    *
    * @param device The platform-specific device name for this serial
    * port.
    */
   explicit basic_serial_port(boost::asio::io_service& io_service,
       const char* device)
     : basic_io_object<SerialPortService>(io_service)
   {
     boost::system::error_code ec;
-    this->get_service().open(this->get_implementation(), device, ec);
-    boost::asio::detail::throw_error(ec, "open");
+    this->service.open(this->implementation, device, ec);
+    boost::asio::detail::throw_error(ec);
   }
 
   /// Construct and open a basic_serial_port.
   /**
    * This constructor creates and opens a serial port for the specified device
    * name.
    *
    * @param io_service The io_service object that the serial port will use to
    * dispatch handlers for any asynchronous operations performed on the port.
    *
    * @param device The platform-specific device name for this serial
    * port.
    */
   explicit basic_serial_port(boost::asio::io_service& io_service,
       const std::string& device)
     : basic_io_object<SerialPortService>(io_service)
   {
     boost::system::error_code ec;
-    this->get_service().open(this->get_implementation(), device, ec);
-    boost::asio::detail::throw_error(ec, "open");
+    this->service.open(this->implementation, device, ec);
+    boost::asio::detail::throw_error(ec);
   }
 
   /// Construct a basic_serial_port on an existing native serial port.
   /**
    * This constructor creates a serial port object to hold an existing native
    * serial port.
    *
    * @param io_service The io_service object that the serial port will use to
    * dispatch handlers for any asynchronous operations performed on the port.
    *
    * @param native_serial_port A native serial port.
    *
    * @throws boost::system::system_error Thrown on failure.
    */
   basic_serial_port(boost::asio::io_service& io_service,
-      const native_handle_type& native_serial_port)
+      const native_type& native_serial_port)
     : basic_io_object<SerialPortService>(io_service)
   {
     boost::system::error_code ec;
-    this->get_service().assign(this->get_implementation(),
-        native_serial_port, ec);
-    boost::asio::detail::throw_error(ec, "assign");
-  }
-
-#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
-  /// Move-construct a basic_serial_port from another.
-  /**
-   * This constructor moves a serial port from one object to another.
-   *
-   * @param other The other basic_serial_port 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_serial_port(io_service&) constructor.
-   */
-  basic_serial_port(basic_serial_port&& other)
-    : basic_io_object<SerialPortService>(
-        BOOST_ASIO_MOVE_CAST(basic_serial_port)(other))
-  {
-  }
-
-  /// Move-assign a basic_serial_port from another.
-  /**
-   * This assignment operator moves a serial port from one object to another.
-   *
-   * @param other The other basic_serial_port 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_serial_port(io_service&) constructor.
-   */
-  basic_serial_port& operator=(basic_serial_port&& other)
-  {
-    basic_io_object<SerialPortService>::operator=(
-        BOOST_ASIO_MOVE_CAST(basic_serial_port)(other));
-    return *this;
+    this->service.assign(this->implementation, native_serial_port, ec);
+    boost::asio::detail::throw_error(ec);
   }
-#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_serial_port cannot contain any further layers, it
    * simply returns a reference to itself.
    *
    * @return A reference to the lowest layer in the stack of layers. Ownership
    * is not transferred to the caller.
    */
   lowest_layer_type& lowest_layer()
   {
     return *this;
   }
 
   /// Get a const reference to the lowest layer.
   /**
    * This function returns a const reference to the lowest layer in a stack of
    * layers. Since a basic_serial_port cannot contain any further layers, it
    * simply returns a reference to itself.
    *
    * @return A const reference to the lowest layer in the stack of layers.
    * Ownership is not transferred to the caller.
    */
   const lowest_layer_type& lowest_layer() const
   {
     return *this;
   }
 
   /// Open the serial port using the specified device name.
   /**
    * This function opens the serial port for the specified device name.
    *
    * @param device The platform-specific device name.
    *
    * @throws boost::system::system_error Thrown on failure.
    */
   void open(const std::string& device)
   {
     boost::system::error_code ec;
-    this->get_service().open(this->get_implementation(), device, ec);
-    boost::asio::detail::throw_error(ec, "open");
+    this->service.open(this->implementation, device, ec);
+    boost::asio::detail::throw_error(ec);
   }
 
   /// Open the serial port using the specified device name.
   /**
    * This function opens the serial port using the given platform-specific
    * device name.
    *
    * @param device The platform-specific device name.
    *
    * @param ec Set the indicate what error occurred, if any.
    */
   boost::system::error_code open(const std::string& device,
       boost::system::error_code& ec)
   {
-    return this->get_service().open(this->get_implementation(), device, ec);
+    return this->service.open(this->implementation, device, ec);
   }
 
   /// Assign an existing native serial port to the serial port.
   /*
    * This function opens the serial port to hold an existing native serial port.
    *
    * @param native_serial_port A native serial port.
    *
    * @throws boost::system::system_error Thrown on failure.
    */
-  void assign(const native_handle_type& native_serial_port)
+  void assign(const native_type& native_serial_port)
   {
     boost::system::error_code ec;
-    this->get_service().assign(this->get_implementation(),
-        native_serial_port, ec);
-    boost::asio::detail::throw_error(ec, "assign");
+    this->service.assign(this->implementation, native_serial_port, ec);
+    boost::asio::detail::throw_error(ec);
   }
 
   /// Assign an existing native serial port to the serial port.
   /*
    * This function opens the serial port to hold an existing native serial port.
    *
    * @param native_serial_port A native serial port.
    *
    * @param ec Set to indicate what error occurred, if any.
    */
-  boost::system::error_code assign(const native_handle_type& native_serial_port,
+  boost::system::error_code assign(const native_type& native_serial_port,
       boost::system::error_code& ec)
   {
-    return this->get_service().assign(this->get_implementation(),
-        native_serial_port, ec);
+    return this->service.assign(this->implementation, native_serial_port, ec);
   }
 
   /// Determine whether the serial port is open.
   bool is_open() const
   {
-    return this->get_service().is_open(this->get_implementation());
+    return this->service.is_open(this->implementation);
   }
 
   /// Close the serial port.
   /**
    * This function is used to close the serial port. Any asynchronous read or
    * write operations will be cancelled immediately, and will complete with the
    * boost::asio::error::operation_aborted error.
    *
    * @throws boost::system::system_error Thrown on failure.
    */
   void close()
   {
     boost::system::error_code ec;
-    this->get_service().close(this->get_implementation(), ec);
-    boost::asio::detail::throw_error(ec, "close");
+    this->service.close(this->implementation, ec);
+    boost::asio::detail::throw_error(ec);
   }
 
   /// Close the serial port.
   /**
    * This function is used to close the serial port. Any asynchronous read or
    * write operations will be cancelled immediately, and will complete with the
    * boost::asio::error::operation_aborted error.
    *
    * @param ec Set to indicate what error occurred, if any.
    */
   boost::system::error_code close(boost::system::error_code& ec)
   {
-    return this->get_service().close(this->get_implementation(), ec);
-  }
-
-  /// (Deprecated: Use native_handle().) Get the native serial port
-  /// representation.
-  /**
-   * This function may be used to obtain the underlying representation of the
-   * serial port. This is intended to allow access to native serial port
-   * functionality that is not otherwise provided.
-   */
-  native_type native()
-  {
-    return this->get_service().native_handle(this->get_implementation());
+    return this->service.close(this->implementation, ec);
   }
 
   /// Get the native serial port representation.
   /**
    * This function may be used to obtain the underlying representation of the
    * serial port. This is intended to allow access to native serial port
    * functionality that is not otherwise provided.
    */
-  native_handle_type native_handle()
+  native_type native()
   {
-    return this->get_service().native_handle(this->get_implementation());
+    return this->service.native(this->implementation);
   }
 
   /// Cancel all asynchronous operations associated with the serial port.
   /**
    * This function causes all outstanding asynchronous read or write operations
    * to finish immediately, and the handlers for cancelled operations will be
    * passed the boost::asio::error::operation_aborted error.
    *
    * @throws boost::system::system_error Thrown on failure.
    */
   void cancel()
   {
     boost::system::error_code ec;
-    this->get_service().cancel(this->get_implementation(), ec);
-    boost::asio::detail::throw_error(ec, "cancel");
+    this->service.cancel(this->implementation, ec);
+    boost::asio::detail::throw_error(ec);
   }
 
   /// Cancel all asynchronous operations associated with the serial port.
   /**
    * This function causes all outstanding asynchronous read or write operations
    * to finish immediately, and the handlers for cancelled operations will be
    * passed the boost::asio::error::operation_aborted error.
    *
    * @param ec Set to indicate what error occurred, if any.
    */
   boost::system::error_code cancel(boost::system::error_code& ec)
   {
-    return this->get_service().cancel(this->get_implementation(), ec);
+    return this->service.cancel(this->implementation, ec);
   }
 
   /// Send a break sequence to the serial port.
   /**
    * This function causes a break sequence of platform-specific duration to be
    * sent out the serial port.
    *
    * @throws boost::system::system_error Thrown on failure.
    */
   void send_break()
   {
     boost::system::error_code ec;
-    this->get_service().send_break(this->get_implementation(), ec);
-    boost::asio::detail::throw_error(ec, "send_break");
+    this->service.send_break(this->implementation, ec);
+    boost::asio::detail::throw_error(ec);
   }
 
   /// Send a break sequence to the serial port.
   /**
    * This function causes a break sequence of platform-specific duration to be
    * sent out the serial port.
    *
    * @param ec Set to indicate what error occurred, if any.
    */
   boost::system::error_code send_break(boost::system::error_code& ec)
   {
-    return this->get_service().send_break(this->get_implementation(), ec);
+    return this->service.send_break(this->implementation, ec);
   }
 
   /// Set an option on the serial port.
   /**
    * This function is used to set an option on the serial port.
    *
    * @param option The option value to be set on the serial port.
    *
    * @throws boost::system::system_error Thrown on failure.
    *
    * @sa SettableSerialPortOption @n
    * boost::asio::serial_port_base::baud_rate @n
    * boost::asio::serial_port_base::flow_control @n
    * boost::asio::serial_port_base::parity @n
    * boost::asio::serial_port_base::stop_bits @n
    * boost::asio::serial_port_base::character_size
    */
   template <typename SettableSerialPortOption>
   void set_option(const SettableSerialPortOption& option)
   {
     boost::system::error_code ec;
-    this->get_service().set_option(this->get_implementation(), option, ec);
-    boost::asio::detail::throw_error(ec, "set_option");
+    this->service.set_option(this->implementation, option, ec);
+    boost::asio::detail::throw_error(ec);
   }
 
   /// Set an option on the serial port.
   /**
    * This function is used to set an option on the serial port.
    *
    * @param option The option value to be set on the serial port.
    *
    * @param ec Set to indicate what error occurred, if any.
    *
    * @sa SettableSerialPortOption @n
    * boost::asio::serial_port_base::baud_rate @n
    * boost::asio::serial_port_base::flow_control @n
    * boost::asio::serial_port_base::parity @n
    * boost::asio::serial_port_base::stop_bits @n
    * boost::asio::serial_port_base::character_size
    */
   template <typename SettableSerialPortOption>
   boost::system::error_code set_option(const SettableSerialPortOption& option,
       boost::system::error_code& ec)
   {
-    return this->get_service().set_option(
-        this->get_implementation(), option, ec);
+    return this->service.set_option(this->implementation, option, ec);
   }
 
   /// Get an option from the serial port.
   /**
    * This function is used to get the current value of an option on the serial
    * port.
    *
    * @param option The option value to be obtained from the serial port.
    *
    * @throws boost::system::system_error Thrown on failure.
    *
    * @sa GettableSerialPortOption @n
    * boost::asio::serial_port_base::baud_rate @n
    * boost::asio::serial_port_base::flow_control @n
    * boost::asio::serial_port_base::parity @n
    * boost::asio::serial_port_base::stop_bits @n
    * boost::asio::serial_port_base::character_size
    */
   template <typename GettableSerialPortOption>
   void get_option(GettableSerialPortOption& option)
   {
     boost::system::error_code ec;
-    this->get_service().get_option(this->get_implementation(), option, ec);
-    boost::asio::detail::throw_error(ec, "get_option");
+    this->service.get_option(this->implementation, option, ec);
+    boost::asio::detail::throw_error(ec);
   }
 
   /// Get an option from the serial port.
   /**
    * This function is used to get the current value of an option on the serial
    * port.
    *
    * @param option The option value to be obtained from the serial port.
    *
    * @param ec Set to indicate what error occured, if any.
    *
    * @sa GettableSerialPortOption @n
    * boost::asio::serial_port_base::baud_rate @n
    * boost::asio::serial_port_base::flow_control @n
    * boost::asio::serial_port_base::parity @n
    * boost::asio::serial_port_base::stop_bits @n
    * boost::asio::serial_port_base::character_size
    */
   template <typename GettableSerialPortOption>
   boost::system::error_code get_option(GettableSerialPortOption& option,
       boost::system::error_code& ec)
   {
-    return this->get_service().get_option(
-        this->get_implementation(), option, ec);
+    return this->service.get_option(this->implementation, option, ec);
   }
 
   /// Write some data to the serial port.
   /**
    * This function is used to write data to the serial port. The function call
    * will block until one or more bytes of the data has been written
    * successfully, or until an error occurs.
    *
    * @param buffers One or more data buffers to be written to the serial port.
    *
    * @returns The number of bytes written.
    *
    * @throws boost::system::system_error Thrown on failure. An error code of
    * boost::asio::error::eof indicates that the connection was closed by the
    * peer.
    *
    * @note The write_some operation may not transmit all of the data to the
    * peer. Consider using the @ref write function if you need to ensure that
    * all data is written before the blocking operation completes.
    *
    * @par Example
    * To write a single data buffer use the @ref buffer function as follows:
    * @code
    * serial_port.write_some(boost::asio::buffer(data, size));
    * @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(const ConstBufferSequence& buffers)
   {
     boost::system::error_code ec;
-    std::size_t s = this->get_service().write_some(
-        this->get_implementation(), buffers, ec);
-    boost::asio::detail::throw_error(ec, "write_some");
+    std::size_t s = this->service.write_some(this->implementation, buffers, ec);
+    boost::asio::detail::throw_error(ec);
     return s;
   }
 
   /// Write some data to the serial port.
   /**
    * This function is used to write data to the serial port. The function call
    * will block until one or more bytes of the data has been written
    * successfully, or until an error occurs.
    *
    * @param buffers One or more data buffers to be written to the serial port.
    *
    * @param ec Set to indicate what error occurred, if any.
    *
    * @returns The number of bytes written. Returns 0 if an error occurred.
    *
    * @note The write_some operation may not transmit all of the data to the
    * peer. Consider using the @ref write function if you need to ensure that
    * all data is written before the blocking operation completes.
    */
   template <typename ConstBufferSequence>
   std::size_t write_some(const ConstBufferSequence& buffers,
       boost::system::error_code& ec)
   {
-    return this->get_service().write_some(
-        this->get_implementation(), buffers, ec);
+    return this->service.write_some(this->implementation, buffers, ec);
   }
 
   /// Start an asynchronous write.
   /**
    * This function is used to asynchronously write data to the serial port.
    * The function call always returns immediately.
    *
    * @param buffers One or more data buffers to be written to the serial port.
    * 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.
    *
    * @param handler The handler to be called when the write operation completes.
    * Copies will be made of the handler as required. The function signature of
    * the handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
    *   std::size_t bytes_transferred           // Number of bytes written.
    * ); @endcode
    * 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().
    *
    * @note The write operation may not transmit all of the data to the peer.
    * Consider using the @ref async_write function if you need to ensure that all
    * data is written before the asynchronous operation completes.
    *
    * @par Example
    * To write a single data buffer use the @ref buffer function as follows:
    * @code
    * serial_port.async_write_some(boost::asio::buffer(data, size), handler);
    * @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_MOVE_ARG(WriteHandler) handler)
+      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(),
-        buffers, BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
+    this->service.async_write_some(this->implementation, buffers, handler);
   }
 
   /// Read some data from the serial port.
   /**
    * This function is used to read data from the serial port. The function
    * call will block until one or more bytes of data has been read successfully,
    * or until an error occurs.
    *
    * @param buffers One or more buffers into which the data will be read.
    *
    * @returns The number of bytes read.
    *
    * @throws boost::system::system_error Thrown on failure. An error code of
    * boost::asio::error::eof indicates that the connection was closed by the
    * peer.
    *
    * @note The read_some operation may not read all of the requested number of
    * bytes. Consider using the @ref read function if you need to ensure that
    * the requested amount of data is read before the blocking operation
    * completes.
    *
    * @par Example
    * To read into a single data buffer use the @ref buffer function as follows:
    * @code
    * serial_port.read_some(boost::asio::buffer(data, size));
    * @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(const MutableBufferSequence& buffers)
   {
     boost::system::error_code ec;
-    std::size_t s = this->get_service().read_some(
-        this->get_implementation(), buffers, ec);
-    boost::asio::detail::throw_error(ec, "read_some");
+    std::size_t s = this->service.read_some(this->implementation, buffers, ec);
+    boost::asio::detail::throw_error(ec);
     return s;
   }
 
   /// Read some data from the serial port.
   /**
    * This function is used to read data from the serial port. The function
    * call will block until one or more bytes of data has been read successfully,
    * or until an error occurs.
    *
    * @param buffers One or more buffers into which the data will be read.
    *
    * @param ec Set to indicate what error occurred, if any.
    *
    * @returns The number of bytes read. Returns 0 if an error occurred.
    *
    * @note The read_some operation may not read all of the requested number of
    * bytes. Consider using the @ref read 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(const MutableBufferSequence& buffers,
       boost::system::error_code& ec)
   {
-    return this->get_service().read_some(
-        this->get_implementation(), buffers, ec);
+    return this->service.read_some(this->implementation, buffers, ec);
   }
 
   /// Start an asynchronous read.
   /**
    * This function is used to asynchronously read data from the serial port.
    * The function call always returns immediately.
    *
    * @param buffers One or more buffers into which the data will be read.
    * 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.
    *
    * @param handler The handler to be called when the read operation completes.
    * Copies will be made of the handler as required. The function signature of
    * the handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
    *   std::size_t bytes_transferred           // Number of bytes read.
    * ); @endcode
    * 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().
    *
    * @note The read operation may not read all of the requested number of bytes.
    * Consider using the @ref async_read function if you need to ensure that the
    * requested amount of data is read before the asynchronous operation
    * completes.
    *
    * @par Example
    * To read into a single data buffer use the @ref buffer function as follows:
    * @code
    * serial_port.async_read_some(boost::asio::buffer(data, size), handler);
    * @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_MOVE_ARG(ReadHandler) handler)
+      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(),
-        buffers, BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
+    this->service.async_read_some(this->implementation, buffers, handler);
   }
 };
 
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // defined(BOOST_ASIO_HAS_SERIAL_PORT)
        //   || defined(GENERATING_DOCUMENTATION)
 
 #endif // BOOST_ASIO_BASIC_SERIAL_PORT_HPP
diff --git a/3rdParty/Boost/src/boost/asio/basic_signal_set.hpp b/3rdParty/Boost/src/boost/asio/basic_signal_set.hpp
deleted file mode 100644
index ddbef87..0000000
--- a/3rdParty/Boost/src/boost/asio/basic_signal_set.hpp
+++ /dev/null
@@ -1,384 +0,0 @@
-//
-// basic_signal_set.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_BASIC_SIGNAL_SET_HPP
-#define BOOST_ASIO_BASIC_SIGNAL_SET_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/basic_io_object.hpp>
-#include <boost/asio/detail/handler_type_requirements.hpp>
-#include <boost/asio/detail/throw_error.hpp>
-#include <boost/asio/error.hpp>
-#include <boost/asio/signal_set_service.hpp>
-
-#include <boost/asio/detail/push_options.hpp>
-
-namespace boost {
-namespace asio {
-
-/// Provides signal functionality.
-/**
- * The basic_signal_set class template provides the ability to perform an
- * asynchronous wait for one or more signals to occur.
- *
- * Most applications will use the boost::asio::signal_set typedef.
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Unsafe.
- *
- * @par Example
- * Performing an asynchronous wait:
- * @code
- * void handler(
- *     const boost::system::error_code& error,
- *     int signal_number)
- * {
- *   if (!error)
- *   {
- *     // A signal occurred.
- *   }
- * }
- *
- * ...
- *
- * // Construct a signal set registered for process termination.
- * boost::asio::signal_set signals(io_service, SIGINT, SIGTERM);
- *
- * // Start an asynchronous wait for one of the signals to occur.
- * signals.async_wait(handler);
- * @endcode
- *
- * @par Queueing of signal notifications
- *
- * If a signal is registered with a signal_set, and the signal occurs when
- * there are no waiting handlers, then the signal notification is queued. The
- * next async_wait operation on that signal_set will dequeue the notification.
- * If multiple notifications are queued, subsequent async_wait operations
- * dequeue them one at a time. Signal notifications are dequeued in order of
- * ascending signal number.
- *
- * If a signal number is removed from a signal_set (using the @c remove or @c
- * erase member functions) then any queued notifications for that signal are
- * discarded.
- *
- * @par Multiple registration of signals
- *
- * The same signal number may be registered with different signal_set objects.
- * When the signal occurs, one handler is called for each signal_set object.
- *
- * Note that multiple registration only works for signals that are registered
- * using Asio. The application must not also register a signal handler using
- * functions such as @c signal() or @c sigaction().
- *
- * @par Signal masking on POSIX platforms
- *
- * POSIX allows signals to be blocked using functions such as @c sigprocmask()
- * and @c pthread_sigmask(). For signals to be delivered, programs must ensure
- * that any signals registered using signal_set objects are unblocked in at
- * least one thread.
- */
-template <typename SignalSetService = signal_set_service>
-class basic_signal_set
-  : public basic_io_object<SignalSetService>
-{
-public:
-  /// Construct a signal set without adding any signals.
-  /**
-   * This constructor creates a signal set without registering for any signals.
-   *
-   * @param io_service The io_service object that the signal set will use to
-   * dispatch handlers for any asynchronous operations performed on the set.
-   */
-  explicit basic_signal_set(boost::asio::io_service& io_service)
-    : basic_io_object<SignalSetService>(io_service)
-  {
-  }
-
-  /// Construct a signal set and add one signal.
-  /**
-   * This constructor creates a signal set and registers for one signal.
-   *
-   * @param io_service The io_service object that the signal set will use to
-   * dispatch handlers for any asynchronous operations performed on the set.
-   *
-   * @param signal_number_1 The signal number to be added.
-   *
-   * @note This constructor is equivalent to performing:
-   * @code boost::asio::signal_set signals(io_service);
-   * signals.add(signal_number_1); @endcode
-   */
-  basic_signal_set(boost::asio::io_service& io_service, int signal_number_1)
-    : basic_io_object<SignalSetService>(io_service)
-  {
-    boost::system::error_code ec;
-    this->service.add(this->implementation, signal_number_1, ec);
-    boost::asio::detail::throw_error(ec, "add");
-  }
-
-  /// Construct a signal set and add two signals.
-  /**
-   * This constructor creates a signal set and registers for two signals.
-   *
-   * @param io_service The io_service object that the signal set will use to
-   * dispatch handlers for any asynchronous operations performed on the set.
-   *
-   * @param signal_number_1 The first signal number to be added.
-   *
-   * @param signal_number_2 The second signal number to be added.
-   *
-   * @note This constructor is equivalent to performing:
-   * @code boost::asio::signal_set signals(io_service);
-   * signals.add(signal_number_1);
-   * signals.add(signal_number_2); @endcode
-   */
-  basic_signal_set(boost::asio::io_service& io_service, int signal_number_1,
-      int signal_number_2)
-    : basic_io_object<SignalSetService>(io_service)
-  {
-    boost::system::error_code ec;
-    this->service.add(this->implementation, signal_number_1, ec);
-    boost::asio::detail::throw_error(ec, "add");
-    this->service.add(this->implementation, signal_number_2, ec);
-    boost::asio::detail::throw_error(ec, "add");
-  }
-
-  /// Construct a signal set and add three signals.
-  /**
-   * This constructor creates a signal set and registers for three signals.
-   *
-   * @param io_service The io_service object that the signal set will use to
-   * dispatch handlers for any asynchronous operations performed on the set.
-   *
-   * @param signal_number_1 The first signal number to be added.
-   *
-   * @param signal_number_2 The second signal number to be added.
-   *
-   * @param signal_number_3 The third signal number to be added.
-   *
-   * @note This constructor is equivalent to performing:
-   * @code boost::asio::signal_set signals(io_service);
-   * signals.add(signal_number_1);
-   * signals.add(signal_number_2);
-   * signals.add(signal_number_3); @endcode
-   */
-  basic_signal_set(boost::asio::io_service& io_service, int signal_number_1,
-      int signal_number_2, int signal_number_3)
-    : basic_io_object<SignalSetService>(io_service)
-  {
-    boost::system::error_code ec;
-    this->service.add(this->implementation, signal_number_1, ec);
-    boost::asio::detail::throw_error(ec, "add");
-    this->service.add(this->implementation, signal_number_2, ec);
-    boost::asio::detail::throw_error(ec, "add");
-    this->service.add(this->implementation, signal_number_3, ec);
-    boost::asio::detail::throw_error(ec, "add");
-  }
-
-  /// Add a signal to a signal_set.
-  /**
-   * This function adds the specified signal to the set. It has no effect if the
-   * signal is already in the set.
-   *
-   * @param signal_number The signal to be added to the set.
-   *
-   * @throws boost::system::system_error Thrown on failure.
-   */
-  void add(int signal_number)
-  {
-    boost::system::error_code ec;
-    this->service.add(this->implementation, signal_number, ec);
-    boost::asio::detail::throw_error(ec, "add");
-  }
-
-  /// Add a signal to a signal_set.
-  /**
-   * This function adds the specified signal to the set. It has no effect if the
-   * signal is already in the set.
-   *
-   * @param signal_number The signal to be added to the set.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   */
-  boost::system::error_code add(int signal_number,
-      boost::system::error_code& ec)
-  {
-    return this->service.add(this->implementation, signal_number, ec);
-  }
-
-  /// Remove a signal from a signal_set.
-  /**
-   * This function removes the specified signal from the set. It has no effect
-   * if the signal is not in the set.
-   *
-   * @param signal_number The signal to be removed from the set.
-   *
-   * @throws boost::system::system_error Thrown on failure.
-   *
-   * @note Removes any notifications that have been queued for the specified
-   * signal number.
-   */
-  void remove(int signal_number)
-  {
-    boost::system::error_code ec;
-    this->service.remove(this->implementation, signal_number, ec);
-    boost::asio::detail::throw_error(ec, "remove");
-  }
-
-  /// Remove a signal from a signal_set.
-  /**
-   * This function removes the specified signal from the set. It has no effect
-   * if the signal is not in the set.
-   *
-   * @param signal_number The signal to be removed from the set.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @note Removes any notifications that have been queued for the specified
-   * signal number.
-   */
-  boost::system::error_code remove(int signal_number,
-      boost::system::error_code& ec)
-  {
-    return this->service.remove(this->implementation, signal_number, ec);
-  }
-
-  /// Remove all signals from a signal_set.
-  /**
-   * This function removes all signals from the set. It has no effect if the set
-   * is already empty.
-   *
-   * @throws boost::system::system_error Thrown on failure.
-   *
-   * @note Removes all queued notifications.
-   */
-  void clear()
-  {
-    boost::system::error_code ec;
-    this->service.clear(this->implementation, ec);
-    boost::asio::detail::throw_error(ec, "clear");
-  }
-
-  /// Remove all signals from a signal_set.
-  /**
-   * This function removes all signals from the set. It has no effect if the set
-   * is already empty.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @note Removes all queued notifications.
-   */
-  boost::system::error_code clear(boost::system::error_code& ec)
-  {
-    return this->service.clear(this->implementation, ec);
-  }
-
-  /// Cancel all operations associated with the signal set.
-  /**
-   * This function forces the completion of any pending asynchronous wait
-   * operations against the signal set. The handler for each cancelled
-   * operation will be invoked with the boost::asio::error::operation_aborted
-   * error code.
-   *
-   * Cancellation does not alter the set of registered signals.
-   *
-   * @throws boost::system::system_error Thrown on failure.
-   *
-   * @note If a registered signal occurred before cancel() is called, then the
-   * handlers for asynchronous wait operations will:
-   *
-   * @li have already been invoked; or
-   *
-   * @li have been queued for invocation in the near future.
-   *
-   * These handlers can no longer be cancelled, and therefore are passed an
-   * error code that indicates the successful completion of the wait operation.
-   */
-  void cancel()
-  {
-    boost::system::error_code ec;
-    this->service.cancel(this->implementation, ec);
-    boost::asio::detail::throw_error(ec, "cancel");
-  }
-
-  /// Cancel all operations associated with the signal set.
-  /**
-   * This function forces the completion of any pending asynchronous wait
-   * operations against the signal set. The handler for each cancelled
-   * operation will be invoked with the boost::asio::error::operation_aborted
-   * error code.
-   *
-   * Cancellation does not alter the set of registered signals.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @note If a registered signal occurred before cancel() is called, then the
-   * handlers for asynchronous wait operations will:
-   *
-   * @li have already been invoked; or
-   *
-   * @li have been queued for invocation in the near future.
-   *
-   * These handlers can no longer be cancelled, and therefore are passed an
-   * error code that indicates the successful completion of the wait operation.
-   */
-  boost::system::error_code cancel(boost::system::error_code& ec)
-  {
-    return this->service.cancel(this->implementation, ec);
-  }
-
-  /// Start an asynchronous operation to wait for a signal to be delivered.
-  /**
-   * This function may be used to initiate an asynchronous wait against the
-   * signal set. It always returns immediately.
-   *
-   * For each call to async_wait(), the supplied handler will be called exactly
-   * once. The handler will be called when:
-   *
-   * @li One of the registered signals in the signal set occurs; or
-   *
-   * @li The signal set was cancelled, in which case the handler is passed the
-   * error code boost::asio::error::operation_aborted.
-   *
-   * @param handler The handler to be called when the signal occurs. Copies
-   * will be made of the handler as required. The function signature of the
-   * handler must be:
-   * @code void handler(
-   *   const boost::system::error_code& error, // Result of operation.
-   *   int signal_number // Indicates which signal occurred.
-   * ); @endcode
-   * 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)
-  {
-    // 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,
-        BOOST_ASIO_MOVE_CAST(SignalHandler)(handler));
-  }
-};
-
-} // namespace asio
-} // namespace boost
-
-#include <boost/asio/detail/pop_options.hpp>
-
-#endif // BOOST_ASIO_BASIC_SIGNAL_SET_HPP
diff --git a/3rdParty/Boost/src/boost/asio/basic_socket.hpp b/3rdParty/Boost/src/boost/asio/basic_socket.hpp
index c9e2045..11ce5c9 100644
--- a/3rdParty/Boost/src/boost/asio/basic_socket.hpp
+++ b/3rdParty/Boost/src/boost/asio/basic_socket.hpp
@@ -1,1464 +1,1062 @@
 //
 // basic_socket.hpp
 // ~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_BASIC_SOCKET_HPP
 #define BOOST_ASIO_BASIC_SOCKET_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/basic_io_object.hpp>
-#include <boost/asio/detail/handler_type_requirements.hpp>
 #include <boost/asio/detail/throw_error.hpp>
 #include <boost/asio/error.hpp>
 #include <boost/asio/socket_base.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 
 /// Provides socket functionality.
 /**
  * The basic_socket class template provides functionality that is common to both
  * stream-oriented and datagram-oriented sockets.
  *
  * @par Thread Safety
  * @e Distinct @e objects: Safe.@n
  * @e Shared @e objects: Unsafe.
  */
 template <typename Protocol, typename SocketService>
 class basic_socket
   : public basic_io_object<SocketService>,
     public socket_base
 {
 public:
-  /// (Deprecated: Use native_handle_type.) The native representation of a
-  /// socket.
-  typedef typename SocketService::native_handle_type native_type;
-
   /// The native representation of a socket.
-  typedef typename SocketService::native_handle_type native_handle_type;
+  typedef typename SocketService::native_type native_type;
 
   /// The protocol type.
   typedef Protocol protocol_type;
 
   /// The endpoint type.
   typedef typename Protocol::endpoint endpoint_type;
 
   /// A basic_socket is always the lowest layer.
   typedef basic_socket<Protocol, SocketService> lowest_layer_type;
 
   /// Construct a basic_socket without opening it.
   /**
    * This constructor creates a socket without opening it.
    *
    * @param io_service The io_service object that the socket will use to
    * dispatch handlers for any asynchronous operations performed on the socket.
    */
   explicit basic_socket(boost::asio::io_service& io_service)
     : basic_io_object<SocketService>(io_service)
   {
   }
 
   /// Construct and open a basic_socket.
   /**
    * This constructor creates and opens a socket.
    *
    * @param io_service The io_service object that the socket will use to
    * dispatch handlers for any asynchronous operations performed on the socket.
    *
    * @param protocol An object specifying protocol parameters to be used.
    *
    * @throws boost::system::system_error Thrown on failure.
    */
   basic_socket(boost::asio::io_service& io_service,
       const protocol_type& protocol)
     : basic_io_object<SocketService>(io_service)
   {
     boost::system::error_code ec;
-    this->get_service().open(this->get_implementation(), protocol, ec);
-    boost::asio::detail::throw_error(ec, "open");
+    this->service.open(this->implementation, protocol, ec);
+    boost::asio::detail::throw_error(ec);
   }
 
   /// Construct a basic_socket, opening it and binding it to the given local
   /// endpoint.
   /**
    * This constructor creates a socket and automatically opens it bound to the
    * specified endpoint on the local machine. The protocol used is the protocol
    * associated with the given endpoint.
    *
    * @param io_service The io_service object that the socket will use to
    * dispatch handlers for any asynchronous operations performed on the socket.
    *
    * @param endpoint An endpoint on the local machine to which the socket will
    * be bound.
    *
    * @throws boost::system::system_error Thrown on failure.
    */
   basic_socket(boost::asio::io_service& io_service,
       const endpoint_type& endpoint)
     : basic_io_object<SocketService>(io_service)
   {
     boost::system::error_code ec;
-    const protocol_type protocol = endpoint.protocol();
-    this->get_service().open(this->get_implementation(), protocol, ec);
-    boost::asio::detail::throw_error(ec, "open");
-    this->get_service().bind(this->get_implementation(), endpoint, ec);
-    boost::asio::detail::throw_error(ec, "bind");
+    this->service.open(this->implementation, endpoint.protocol(), ec);
+    boost::asio::detail::throw_error(ec);
+    this->service.bind(this->implementation, endpoint, ec);
+    boost::asio::detail::throw_error(ec);
   }
 
   /// Construct a basic_socket on an existing native socket.
   /**
    * This constructor creates a socket object to hold an existing native socket.
    *
    * @param io_service The io_service object that the socket will use to
    * dispatch handlers for any asynchronous operations performed on the socket.
    *
    * @param protocol An object specifying protocol parameters to be used.
    *
    * @param native_socket A native socket.
    *
    * @throws boost::system::system_error Thrown on failure.
    */
   basic_socket(boost::asio::io_service& io_service,
-      const protocol_type& protocol, const native_handle_type& native_socket)
+      const protocol_type& protocol, const native_type& native_socket)
     : basic_io_object<SocketService>(io_service)
   {
     boost::system::error_code ec;
-    this->get_service().assign(this->get_implementation(),
-        protocol, native_socket, ec);
-    boost::asio::detail::throw_error(ec, "assign");
+    this->service.assign(this->implementation, protocol, native_socket, ec);
+    boost::asio::detail::throw_error(ec);
   }
 
-#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
-  /// Move-construct a basic_socket from another.
-  /**
-   * 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.
-   */
-  basic_socket(basic_socket&& other)
-    : basic_io_object<SocketService>(
-        BOOST_ASIO_MOVE_CAST(basic_socket)(other))
-  {
-  }
-
-  /// Move-assign a basic_socket from another.
-  /**
-   * 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.
-   */
-  basic_socket& operator=(basic_socket&& other)
-  {
-    basic_io_object<SocketService>::operator=(
-        BOOST_ASIO_MOVE_CAST(basic_socket)(other));
-    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
    * returns a reference to itself.
    *
    * @return A reference to the lowest layer in the stack of layers. Ownership
    * is not transferred to the caller.
    */
   lowest_layer_type& lowest_layer()
   {
     return *this;
   }
 
   /// Get a const reference to the lowest layer.
   /**
    * This function returns a const reference to the lowest layer in a stack of
    * layers. Since a basic_socket cannot contain any further layers, it simply
    * returns a reference to itself.
    *
    * @return A const reference to the lowest layer in the stack of layers.
    * Ownership is not transferred to the caller.
    */
   const lowest_layer_type& lowest_layer() const
   {
     return *this;
   }
 
   /// Open the socket using the specified protocol.
   /**
    * This function opens the socket so that it will use the specified protocol.
    *
    * @param protocol An object specifying protocol parameters to be used.
    *
    * @throws boost::system::system_error Thrown on failure.
    *
    * @par Example
    * @code
    * boost::asio::ip::tcp::socket socket(io_service);
    * socket.open(boost::asio::ip::tcp::v4());
    * @endcode
    */
   void open(const protocol_type& protocol = protocol_type())
   {
     boost::system::error_code ec;
-    this->get_service().open(this->get_implementation(), protocol, ec);
-    boost::asio::detail::throw_error(ec, "open");
+    this->service.open(this->implementation, protocol, ec);
+    boost::asio::detail::throw_error(ec);
   }
 
   /// Open the socket using the specified protocol.
   /**
    * This function opens the socket so that it will use the specified protocol.
    *
    * @param protocol An object specifying which protocol is to be used.
    *
    * @param ec Set to indicate what error occurred, if any.
    *
    * @par Example
    * @code
    * boost::asio::ip::tcp::socket socket(io_service);
    * boost::system::error_code ec;
    * socket.open(boost::asio::ip::tcp::v4(), ec);
    * if (ec)
    * {
    *   // An error occurred.
    * }
    * @endcode
    */
   boost::system::error_code open(const protocol_type& protocol,
       boost::system::error_code& ec)
   {
-    return this->get_service().open(this->get_implementation(), protocol, ec);
+    return this->service.open(this->implementation, protocol, ec);
   }
 
   /// Assign an existing native socket to the socket.
   /*
    * This function opens the socket to hold an existing native socket.
    *
    * @param protocol An object specifying which protocol is to be used.
    *
    * @param native_socket A native socket.
    *
    * @throws boost::system::system_error Thrown on failure.
    */
-  void assign(const protocol_type& protocol,
-      const native_handle_type& native_socket)
+  void assign(const protocol_type& protocol, const native_type& native_socket)
   {
     boost::system::error_code ec;
-    this->get_service().assign(this->get_implementation(),
-        protocol, native_socket, ec);
-    boost::asio::detail::throw_error(ec, "assign");
+    this->service.assign(this->implementation, protocol, native_socket, ec);
+    boost::asio::detail::throw_error(ec);
   }
 
   /// Assign an existing native socket to the socket.
   /*
    * This function opens the socket to hold an existing native socket.
    *
    * @param protocol An object specifying which protocol is to be used.
    *
    * @param native_socket A native socket.
    *
    * @param ec Set to indicate what error occurred, if any.
    */
   boost::system::error_code assign(const protocol_type& protocol,
-      const native_handle_type& native_socket, boost::system::error_code& ec)
+      const native_type& native_socket, boost::system::error_code& ec)
   {
-    return this->get_service().assign(this->get_implementation(),
+    return this->service.assign(this->implementation,
         protocol, native_socket, ec);
   }
 
   /// Determine whether the socket is open.
   bool is_open() const
   {
-    return this->get_service().is_open(this->get_implementation());
+    return this->service.is_open(this->implementation);
   }
 
   /// Close the socket.
   /**
    * This function is used to close the socket. Any asynchronous send, receive
    * or connect operations will be cancelled immediately, and will complete
    * with the boost::asio::error::operation_aborted error.
    *
-   * @throws boost::system::system_error Thrown on failure. Note that, even if
-   * the function indicates an error, the underlying descriptor is closed.
+   * @throws boost::system::system_error Thrown on failure.
    *
    * @note For portable behaviour with respect to graceful closure of a
    * connected socket, call shutdown() before closing the socket.
    */
   void close()
   {
     boost::system::error_code ec;
-    this->get_service().close(this->get_implementation(), ec);
-    boost::asio::detail::throw_error(ec, "close");
+    this->service.close(this->implementation, ec);
+    boost::asio::detail::throw_error(ec);
   }
 
   /// Close the socket.
   /**
    * This function is used to close the socket. Any asynchronous send, receive
    * or connect operations will be cancelled immediately, and will complete
    * with the boost::asio::error::operation_aborted error.
    *
-   * @param ec Set to indicate what error occurred, if any. Note that, even if
-   * the function indicates an error, the underlying descriptor is closed.
+   * @param ec Set to indicate what error occurred, if any.
    *
    * @par Example
    * @code
    * boost::asio::ip::tcp::socket socket(io_service);
    * ...
    * boost::system::error_code ec;
    * socket.close(ec);
    * if (ec)
    * {
    *   // An error occurred.
    * }
    * @endcode
    *
    * @note For portable behaviour with respect to graceful closure of a
    * connected socket, call shutdown() before closing the socket.
    */
   boost::system::error_code close(boost::system::error_code& ec)
   {
-    return this->get_service().close(this->get_implementation(), ec);
-  }
-
-  /// (Deprecated: Use native_handle().) Get the native socket representation.
-  /**
-   * This function may be used to obtain the underlying representation of the
-   * socket. This is intended to allow access to native socket functionality
-   * that is not otherwise provided.
-   */
-  native_type native()
-  {
-    return this->get_service().native_handle(this->get_implementation());
+    return this->service.close(this->implementation, ec);
   }
 
   /// Get the native socket representation.
   /**
    * This function may be used to obtain the underlying representation of the
    * socket. This is intended to allow access to native socket functionality
    * that is not otherwise provided.
    */
-  native_handle_type native_handle()
+  native_type native()
   {
-    return this->get_service().native_handle(this->get_implementation());
+    return this->service.native(this->implementation);
   }
 
   /// Cancel all asynchronous operations associated with the socket.
   /**
    * This function causes all outstanding asynchronous connect, send and receive
    * operations to finish immediately, and the handlers for cancelled operations
    * will be passed the boost::asio::error::operation_aborted error.
    *
    * @throws boost::system::system_error Thrown on failure.
    *
    * @note Calls to cancel() will always fail with
    * boost::asio::error::operation_not_supported when run on Windows XP, Windows
    * Server 2003, and earlier versions of Windows, unless
    * BOOST_ASIO_ENABLE_CANCELIO is defined. However, the CancelIo function has
    * two issues that should be considered before enabling its use:
    *
    * @li It will only cancel asynchronous operations that were initiated in the
    * current thread.
    *
    * @li It can appear to complete without error, but the request to cancel the
    * unfinished operations may be silently ignored by the operating system.
    * Whether it works or not seems to depend on the drivers that are installed.
    *
    * For portable cancellation, consider using one of the following
    * alternatives:
    *
    * @li Disable asio's I/O completion port backend by defining
    * BOOST_ASIO_DISABLE_IOCP.
    *
    * @li Use the close() function to simultaneously cancel the outstanding
    * 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) \
   && (!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
   void cancel()
   {
     boost::system::error_code ec;
-    this->get_service().cancel(this->get_implementation(), ec);
-    boost::asio::detail::throw_error(ec, "cancel");
+    this->service.cancel(this->implementation, ec);
+    boost::asio::detail::throw_error(ec);
   }
 
   /// Cancel all asynchronous operations associated with the socket.
   /**
    * This function causes all outstanding asynchronous connect, send and receive
    * operations to finish immediately, and the handlers for cancelled operations
    * will be passed the boost::asio::error::operation_aborted error.
    *
    * @param ec Set to indicate what error occurred, if any.
    *
    * @note Calls to cancel() will always fail with
    * boost::asio::error::operation_not_supported when run on Windows XP, Windows
    * Server 2003, and earlier versions of Windows, unless
    * BOOST_ASIO_ENABLE_CANCELIO is defined. However, the CancelIo function has
    * two issues that should be considered before enabling its use:
    *
    * @li It will only cancel asynchronous operations that were initiated in the
    * current thread.
    *
    * @li It can appear to complete without error, but the request to cancel the
    * unfinished operations may be silently ignored by the operating system.
    * Whether it works or not seems to depend on the drivers that are installed.
    *
    * For portable cancellation, consider using one of the following
    * alternatives:
    *
    * @li Disable asio's I/O completion port backend by defining
    * BOOST_ASIO_DISABLE_IOCP.
    *
    * @li Use the close() function to simultaneously cancel the outstanding
    * 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) \
   && (!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
   boost::system::error_code cancel(boost::system::error_code& ec)
   {
-    return this->get_service().cancel(this->get_implementation(), ec);
+    return this->service.cancel(this->implementation, ec);
   }
 
   /// Determine whether the socket is at the out-of-band data mark.
   /**
    * This function is used to check whether the socket input is currently
    * positioned at the out-of-band data mark.
    *
    * @return A bool indicating whether the socket is at the out-of-band data
    * mark.
    *
    * @throws boost::system::system_error Thrown on failure.
    */
   bool at_mark() const
   {
     boost::system::error_code ec;
-    bool b = this->get_service().at_mark(this->get_implementation(), ec);
-    boost::asio::detail::throw_error(ec, "at_mark");
+    bool b = this->service.at_mark(this->implementation, ec);
+    boost::asio::detail::throw_error(ec);
     return b;
   }
 
   /// Determine whether the socket is at the out-of-band data mark.
   /**
    * This function is used to check whether the socket input is currently
    * positioned at the out-of-band data mark.
    *
    * @param ec Set to indicate what error occurred, if any.
    *
    * @return A bool indicating whether the socket is at the out-of-band data
    * mark.
    */
   bool at_mark(boost::system::error_code& ec) const
   {
-    return this->get_service().at_mark(this->get_implementation(), ec);
+    return this->service.at_mark(this->implementation, ec);
   }
 
   /// Determine the number of bytes available for reading.
   /**
    * This function is used to determine the number of bytes that may be read
    * without blocking.
    *
    * @return The number of bytes that may be read without blocking, or 0 if an
    * error occurs.
    *
    * @throws boost::system::system_error Thrown on failure.
    */
   std::size_t available() const
   {
     boost::system::error_code ec;
-    std::size_t s = this->get_service().available(
-        this->get_implementation(), ec);
-    boost::asio::detail::throw_error(ec, "available");
+    std::size_t s = this->service.available(this->implementation, ec);
+    boost::asio::detail::throw_error(ec);
     return s;
   }
 
   /// Determine the number of bytes available for reading.
   /**
    * This function is used to determine the number of bytes that may be read
    * without blocking.
    *
    * @param ec Set to indicate what error occurred, if any.
    *
    * @return The number of bytes that may be read without blocking, or 0 if an
    * error occurs.
    */
   std::size_t available(boost::system::error_code& ec) const
   {
-    return this->get_service().available(this->get_implementation(), ec);
+    return this->service.available(this->implementation, ec);
   }
 
   /// Bind the socket to the given local endpoint.
   /**
    * This function binds the socket to the specified endpoint on the local
    * machine.
    *
    * @param endpoint An endpoint on the local machine to which the socket will
    * be bound.
    *
    * @throws boost::system::system_error Thrown on failure.
    *
    * @par Example
    * @code
    * boost::asio::ip::tcp::socket socket(io_service);
    * socket.open(boost::asio::ip::tcp::v4());
    * socket.bind(boost::asio::ip::tcp::endpoint(
    *       boost::asio::ip::tcp::v4(), 12345));
    * @endcode
    */
   void bind(const endpoint_type& endpoint)
   {
     boost::system::error_code ec;
-    this->get_service().bind(this->get_implementation(), endpoint, ec);
-    boost::asio::detail::throw_error(ec, "bind");
+    this->service.bind(this->implementation, endpoint, ec);
+    boost::asio::detail::throw_error(ec);
   }
 
   /// Bind the socket to the given local endpoint.
   /**
    * This function binds the socket to the specified endpoint on the local
    * machine.
    *
    * @param endpoint An endpoint on the local machine to which the socket will
    * be bound.
    *
    * @param ec Set to indicate what error occurred, if any.
    *
    * @par Example
    * @code
    * boost::asio::ip::tcp::socket socket(io_service);
    * socket.open(boost::asio::ip::tcp::v4());
    * boost::system::error_code ec;
    * socket.bind(boost::asio::ip::tcp::endpoint(
    *       boost::asio::ip::tcp::v4(), 12345), ec);
    * if (ec)
    * {
    *   // An error occurred.
    * }
    * @endcode
    */
   boost::system::error_code bind(const endpoint_type& endpoint,
       boost::system::error_code& ec)
   {
-    return this->get_service().bind(this->get_implementation(), endpoint, ec);
+    return this->service.bind(this->implementation, endpoint, ec);
   }
 
   /// Connect the socket to the specified endpoint.
   /**
    * This function is used to connect a socket to the specified remote endpoint.
    * The function call will block until the connection is successfully made or
    * an error occurs.
    *
    * The socket is automatically opened if it is not already open. If the
    * connect fails, and the socket was automatically opened, the socket is
    * not returned to the closed state.
    *
    * @param peer_endpoint The remote endpoint to which the socket will be
    * connected.
    *
    * @throws boost::system::system_error Thrown on failure.
    *
    * @par Example
    * @code
    * boost::asio::ip::tcp::socket socket(io_service);
    * boost::asio::ip::tcp::endpoint endpoint(
    *     boost::asio::ip::address::from_string("1.2.3.4"), 12345);
    * socket.connect(endpoint);
    * @endcode
    */
   void connect(const endpoint_type& peer_endpoint)
   {
     boost::system::error_code ec;
     if (!is_open())
     {
-      this->get_service().open(this->get_implementation(),
-          peer_endpoint.protocol(), ec);
-      boost::asio::detail::throw_error(ec, "connect");
+      this->service.open(this->implementation, peer_endpoint.protocol(), ec);
+      boost::asio::detail::throw_error(ec);
     }
-    this->get_service().connect(this->get_implementation(), peer_endpoint, ec);
-    boost::asio::detail::throw_error(ec, "connect");
+    this->service.connect(this->implementation, peer_endpoint, ec);
+    boost::asio::detail::throw_error(ec);
   }
 
   /// Connect the socket to the specified endpoint.
   /**
    * This function is used to connect a socket to the specified remote endpoint.
    * The function call will block until the connection is successfully made or
    * an error occurs.
    *
    * The socket is automatically opened if it is not already open. If the
    * connect fails, and the socket was automatically opened, the socket is
    * not returned to the closed state.
    *
    * @param peer_endpoint The remote endpoint to which the socket will be
    * connected.
    *
    * @param ec Set to indicate what error occurred, if any.
    *
    * @par Example
    * @code
    * boost::asio::ip::tcp::socket socket(io_service);
    * boost::asio::ip::tcp::endpoint endpoint(
    *     boost::asio::ip::address::from_string("1.2.3.4"), 12345);
    * boost::system::error_code ec;
    * socket.connect(endpoint, ec);
    * if (ec)
    * {
    *   // An error occurred.
    * }
    * @endcode
    */
   boost::system::error_code connect(const endpoint_type& peer_endpoint,
       boost::system::error_code& ec)
   {
     if (!is_open())
     {
-      if (this->get_service().open(this->get_implementation(),
+      if (this->service.open(this->implementation,
             peer_endpoint.protocol(), ec))
       {
         return ec;
       }
     }
 
-    return this->get_service().connect(
-        this->get_implementation(), peer_endpoint, ec);
+    return this->service.connect(this->implementation, peer_endpoint, ec);
   }
 
   /// Start an asynchronous connect.
   /**
    * This function is used to asynchronously connect a socket to the specified
    * remote endpoint. The function call always returns immediately.
    *
    * The socket is automatically opened if it is not already open. If the
    * connect fails, and the socket was automatically opened, the socket is
    * not returned to the closed state.
    *
    * @param peer_endpoint The remote endpoint to which the socket will be
    * connected. Copies will be made of the endpoint object as required.
    *
    * @param handler The handler to be called when the connection operation
    * completes. Copies will be made of the handler as required. The function
    * signature of the handler must be:
    * @code void handler(
    *   const boost::system::error_code& error // Result of operation
    * ); @endcode
    * 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().
    *
    * @par Example
    * @code
    * void connect_handler(const boost::system::error_code& error)
    * {
    *   if (!error)
    *   {
    *     // Connect succeeded.
    *   }
    * }
    *
    * ...
    *
    * boost::asio::ip::tcp::socket socket(io_service);
    * 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_MOVE_ARG(ConnectHandler) handler)
+  void async_connect(const endpoint_type& peer_endpoint, 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))
+      if (this->service.open(this->implementation,
+            peer_endpoint.protocol(), ec))
       {
         this->get_io_service().post(
-            boost::asio::detail::bind_handler(
-              BOOST_ASIO_MOVE_CAST(ConnectHandler)(handler), ec));
+            boost::asio::detail::bind_handler(handler, ec));
         return;
       }
     }
 
-    this->get_service().async_connect(this->get_implementation(),
-        peer_endpoint, BOOST_ASIO_MOVE_CAST(ConnectHandler)(handler));
+    this->service.async_connect(this->implementation, peer_endpoint, handler);
   }
 
   /// Set an option on the socket.
   /**
    * This function is used to set an option on the socket.
    *
    * @param option The new option value to be set on the socket.
    *
    * @throws boost::system::system_error Thrown on failure.
    *
    * @sa SettableSocketOption @n
    * boost::asio::socket_base::broadcast @n
    * boost::asio::socket_base::do_not_route @n
    * boost::asio::socket_base::keep_alive @n
    * boost::asio::socket_base::linger @n
    * boost::asio::socket_base::receive_buffer_size @n
    * boost::asio::socket_base::receive_low_watermark @n
    * boost::asio::socket_base::reuse_address @n
    * boost::asio::socket_base::send_buffer_size @n
    * boost::asio::socket_base::send_low_watermark @n
    * boost::asio::ip::multicast::join_group @n
    * boost::asio::ip::multicast::leave_group @n
    * boost::asio::ip::multicast::enable_loopback @n
    * boost::asio::ip::multicast::outbound_interface @n
    * boost::asio::ip::multicast::hops @n
    * boost::asio::ip::tcp::no_delay
    *
    * @par Example
    * Setting the IPPROTO_TCP/TCP_NODELAY option:
    * @code
    * boost::asio::ip::tcp::socket socket(io_service);
    * ...
    * boost::asio::ip::tcp::no_delay option(true);
    * socket.set_option(option);
    * @endcode
    */
   template <typename SettableSocketOption>
   void set_option(const SettableSocketOption& option)
   {
     boost::system::error_code ec;
-    this->get_service().set_option(this->get_implementation(), option, ec);
-    boost::asio::detail::throw_error(ec, "set_option");
+    this->service.set_option(this->implementation, option, ec);
+    boost::asio::detail::throw_error(ec);
   }
 
   /// Set an option on the socket.
   /**
    * This function is used to set an option on the socket.
    *
    * @param option The new option value to be set on the socket.
    *
    * @param ec Set to indicate what error occurred, if any.
    *
    * @sa SettableSocketOption @n
    * boost::asio::socket_base::broadcast @n
    * boost::asio::socket_base::do_not_route @n
    * boost::asio::socket_base::keep_alive @n
    * boost::asio::socket_base::linger @n
    * boost::asio::socket_base::receive_buffer_size @n
    * boost::asio::socket_base::receive_low_watermark @n
    * boost::asio::socket_base::reuse_address @n
    * boost::asio::socket_base::send_buffer_size @n
    * boost::asio::socket_base::send_low_watermark @n
    * boost::asio::ip::multicast::join_group @n
    * boost::asio::ip::multicast::leave_group @n
    * boost::asio::ip::multicast::enable_loopback @n
    * boost::asio::ip::multicast::outbound_interface @n
    * boost::asio::ip::multicast::hops @n
    * boost::asio::ip::tcp::no_delay
    *
    * @par Example
    * Setting the IPPROTO_TCP/TCP_NODELAY option:
    * @code
    * boost::asio::ip::tcp::socket socket(io_service);
    * ...
    * boost::asio::ip::tcp::no_delay option(true);
    * boost::system::error_code ec;
    * socket.set_option(option, ec);
    * if (ec)
    * {
    *   // An error occurred.
    * }
    * @endcode
    */
   template <typename SettableSocketOption>
   boost::system::error_code set_option(const SettableSocketOption& option,
       boost::system::error_code& ec)
   {
-    return this->get_service().set_option(
-        this->get_implementation(), option, ec);
+    return this->service.set_option(this->implementation, option, ec);
   }
 
   /// Get an option from the socket.
   /**
    * This function is used to get the current value of an option on the socket.
    *
    * @param option The option value to be obtained from the socket.
    *
    * @throws boost::system::system_error Thrown on failure.
    *
    * @sa GettableSocketOption @n
    * boost::asio::socket_base::broadcast @n
    * boost::asio::socket_base::do_not_route @n
    * boost::asio::socket_base::keep_alive @n
    * boost::asio::socket_base::linger @n
    * boost::asio::socket_base::receive_buffer_size @n
    * boost::asio::socket_base::receive_low_watermark @n
    * boost::asio::socket_base::reuse_address @n
    * boost::asio::socket_base::send_buffer_size @n
    * boost::asio::socket_base::send_low_watermark @n
    * boost::asio::ip::multicast::join_group @n
    * boost::asio::ip::multicast::leave_group @n
    * boost::asio::ip::multicast::enable_loopback @n
    * boost::asio::ip::multicast::outbound_interface @n
    * boost::asio::ip::multicast::hops @n
    * boost::asio::ip::tcp::no_delay
    *
    * @par Example
    * 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();
    * @endcode
    */
   template <typename GettableSocketOption>
   void get_option(GettableSocketOption& option) const
   {
     boost::system::error_code ec;
-    this->get_service().get_option(this->get_implementation(), option, ec);
-    boost::asio::detail::throw_error(ec, "get_option");
+    this->service.get_option(this->implementation, option, ec);
+    boost::asio::detail::throw_error(ec);
   }
 
   /// Get an option from the socket.
   /**
    * This function is used to get the current value of an option on the socket.
    *
    * @param option The option value to be obtained from the socket.
    *
    * @param ec Set to indicate what error occurred, if any.
    *
    * @sa GettableSocketOption @n
    * boost::asio::socket_base::broadcast @n
    * boost::asio::socket_base::do_not_route @n
    * boost::asio::socket_base::keep_alive @n
    * boost::asio::socket_base::linger @n
    * boost::asio::socket_base::receive_buffer_size @n
    * boost::asio::socket_base::receive_low_watermark @n
    * boost::asio::socket_base::reuse_address @n
    * boost::asio::socket_base::send_buffer_size @n
    * boost::asio::socket_base::send_low_watermark @n
    * boost::asio::ip::multicast::join_group @n
    * boost::asio::ip::multicast::leave_group @n
    * boost::asio::ip::multicast::enable_loopback @n
    * boost::asio::ip::multicast::outbound_interface @n
    * boost::asio::ip::multicast::hops @n
    * boost::asio::ip::tcp::no_delay
    *
    * @par Example
    * 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;
    * boost::system::error_code ec;
    * socket.get_option(option, ec);
    * if (ec)
    * {
    *   // An error occurred.
    * }
    * bool is_set = option.get();
    * @endcode
    */
   template <typename GettableSocketOption>
   boost::system::error_code get_option(GettableSocketOption& option,
       boost::system::error_code& ec) const
   {
-    return this->get_service().get_option(
-        this->get_implementation(), option, ec);
+    return this->service.get_option(this->implementation, option, ec);
   }
 
   /// Perform an IO control command on the socket.
   /**
    * This function is used to execute an IO control command on the socket.
    *
    * @param command The IO control command to be performed on the socket.
    *
    * @throws boost::system::system_error Thrown on failure.
    *
    * @sa IoControlCommand @n
    * boost::asio::socket_base::bytes_readable @n
    * boost::asio::socket_base::non_blocking_io
    *
    * @par Example
    * Getting the number of bytes ready to read:
    * @code
    * boost::asio::ip::tcp::socket socket(io_service);
    * ...
    * boost::asio::ip::tcp::socket::bytes_readable command;
    * socket.io_control(command);
    * std::size_t bytes_readable = command.get();
    * @endcode
    */
   template <typename IoControlCommand>
   void io_control(IoControlCommand& command)
   {
     boost::system::error_code ec;
-    this->get_service().io_control(this->get_implementation(), command, ec);
-    boost::asio::detail::throw_error(ec, "io_control");
+    this->service.io_control(this->implementation, command, ec);
+    boost::asio::detail::throw_error(ec);
   }
 
   /// Perform an IO control command on the socket.
   /**
    * This function is used to execute an IO control command on the socket.
    *
    * @param command The IO control command to be performed on the socket.
    *
    * @param ec Set to indicate what error occurred, if any.
    *
    * @sa IoControlCommand @n
    * boost::asio::socket_base::bytes_readable @n
    * boost::asio::socket_base::non_blocking_io
    *
    * @par Example
    * Getting the number of bytes ready to read:
    * @code
    * boost::asio::ip::tcp::socket socket(io_service);
    * ...
    * boost::asio::ip::tcp::socket::bytes_readable command;
    * boost::system::error_code ec;
    * socket.io_control(command, ec);
    * if (ec)
    * {
    *   // An error occurred.
    * }
    * std::size_t bytes_readable = command.get();
    * @endcode
    */
   template <typename IoControlCommand>
   boost::system::error_code io_control(IoControlCommand& command,
       boost::system::error_code& ec)
   {
-    return this->get_service().io_control(
-        this->get_implementation(), command, ec);
-  }
-
-  /// Gets the non-blocking mode of the socket.
-  /**
-   * @returns @c true if the socket's synchronous operations will fail with
-   * boost::asio::error::would_block if they are unable to perform the requested
-   * operation immediately. If @c false, synchronous operations will block
-   * until complete.
-   *
-   * @note The non-blocking mode has no effect on the behaviour of asynchronous
-   * operations. Asynchronous operations will never fail with the error
-   * boost::asio::error::would_block.
-   */
-  bool non_blocking() const
-  {
-    return this->get_service().non_blocking(this->get_implementation());
-  }
-
-  /// Sets the non-blocking mode of the socket.
-  /**
-   * @param mode If @c true, the socket's synchronous operations will fail with
-   * boost::asio::error::would_block if they are unable to perform the requested
-   * operation immediately. If @c false, synchronous operations will block
-   * until complete.
-   *
-   * @throws boost::system::system_error Thrown on failure.
-   *
-   * @note The non-blocking mode has no effect on the behaviour of asynchronous
-   * operations. Asynchronous operations will never fail with the error
-   * boost::asio::error::would_block.
-   */
-  void non_blocking(bool mode)
-  {
-    boost::system::error_code ec;
-    this->get_service().non_blocking(this->get_implementation(), mode, ec);
-    boost::asio::detail::throw_error(ec, "non_blocking");
-  }
-
-  /// Sets the non-blocking mode of the socket.
-  /**
-   * @param mode If @c true, the socket's synchronous operations will fail with
-   * boost::asio::error::would_block if they are unable to perform the requested
-   * operation immediately. If @c false, synchronous operations will block
-   * until complete.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @note The non-blocking mode has no effect on the behaviour of asynchronous
-   * operations. Asynchronous operations will never fail with the error
-   * boost::asio::error::would_block.
-   */
-  boost::system::error_code non_blocking(
-      bool mode, boost::system::error_code& ec)
-  {
-    return this->get_service().non_blocking(
-        this->get_implementation(), mode, ec);
-  }
-
-  /// Gets the non-blocking mode of the native socket implementation.
-  /**
-   * This function is used to retrieve the non-blocking mode of the underlying
-   * native socket. This mode has no effect on the behaviour of the socket
-   * object's synchronous operations.
-   *
-   * @returns @c true if the underlying socket is in non-blocking mode and
-   * direct system calls may fail with boost::asio::error::would_block (or the
-   * equivalent system error).
-   *
-   * @note The current non-blocking mode is cached by the socket object.
-   * Consequently, the return value may be incorrect if the non-blocking mode
-   * was set directly on the native socket.
-   *
-   * @par Example
-   * This function is intended to allow the encapsulation of arbitrary
-   * non-blocking system calls as asynchronous operations, in a way that is
-   * transparent to the user of the socket object. The following example
-   * illustrates how Linux's @c sendfile system call might be encapsulated:
-   * @code template <typename Handler>
-   * struct sendfile_op
-   * {
-   *   tcp::socket& sock_;
-   *   int fd_;
-   *   Handler handler_;
-   *   off_t offset_;
-   *   std::size_t total_bytes_transferred_;
-   *
-   *   // Function call operator meeting WriteHandler requirements.
-   *   // Used as the handler for the async_write_some operation.
-   *   void operator()(boost::system::error_code ec, std::size_t)
-   *   {
-   *     // Put the underlying socket into non-blocking mode.
-   *     if (!ec)
-   *       if (!sock_.native_non_blocking())
-   *         sock_.native_non_blocking(true, ec);
-   *
-   *     if (!ec)
-   *     {
-   *       for (;;)
-   *       {
-   *         // Try the system call.
-   *         errno = 0;
-   *         int n = ::sendfile(sock_.native_handle(), fd_, &offset_, 65536);
-   *         ec = boost::system::error_code(n < 0 ? errno : 0,
-   *             boost::asio::error::get_system_category());
-   *         total_bytes_transferred_ += ec ? 0 : n;
-   *
-   *         // Retry operation immediately if interrupted by signal.
-   *         if (ec == boost::asio::error::interrupted)
-   *           continue;
-   *
-   *         // Check if we need to run the operation again.
-   *         if (ec == boost::asio::error::would_block
-   *             || ec == boost::asio::error::try_again)
-   *         {
-   *           // We have to wait for the socket to become ready again.
-   *           sock_.async_write_some(boost::asio::null_buffers(), *this);
-   *           return;
-   *         }
-   *
-   *         if (ec || n == 0)
-   *         {
-   *           // An error occurred, or we have reached the end of the file.
-   *           // Either way we must exit the loop so we can call the handler.
-   *           break;
-   *         }
-   *
-   *         // Loop around to try calling sendfile again.
-   *       }
-   *     }
-   *
-   *     // Pass result back to user's handler.
-   *     handler_(ec, total_bytes_transferred_);
-   *   }
-   * };
-   *
-   * template <typename Handler>
-   * void async_sendfile(tcp::socket& sock, int fd, Handler h)
-   * {
-   *   sendfile_op<Handler> op = { sock, fd, h, 0, 0 };
-   *   sock.async_write_some(boost::asio::null_buffers(), op);
-   * } @endcode
-   */
-  bool native_non_blocking() const
-  {
-    return this->get_service().native_non_blocking(this->get_implementation());
-  }
-
-  /// Sets the non-blocking mode of the native socket implementation.
-  /**
-   * This function is used to modify the non-blocking mode of the underlying
-   * native socket. It has no effect on the behaviour of the socket object's
-   * synchronous operations.
-   *
-   * @param mode If @c true, the underlying socket is put into non-blocking
-   * mode and direct system calls may fail with boost::asio::error::would_block
-   * (or the equivalent system error).
-   *
-   * @throws boost::system::system_error Thrown on failure. If the @c mode is
-   * @c false, but the current value of @c non_blocking() is @c true, this
-   * function fails with boost::asio::error::invalid_argument, as the
-   * combination does not make sense.
-   *
-   * @par Example
-   * This function is intended to allow the encapsulation of arbitrary
-   * non-blocking system calls as asynchronous operations, in a way that is
-   * transparent to the user of the socket object. The following example
-   * illustrates how Linux's @c sendfile system call might be encapsulated:
-   * @code template <typename Handler>
-   * struct sendfile_op
-   * {
-   *   tcp::socket& sock_;
-   *   int fd_;
-   *   Handler handler_;
-   *   off_t offset_;
-   *   std::size_t total_bytes_transferred_;
-   *
-   *   // Function call operator meeting WriteHandler requirements.
-   *   // Used as the handler for the async_write_some operation.
-   *   void operator()(boost::system::error_code ec, std::size_t)
-   *   {
-   *     // Put the underlying socket into non-blocking mode.
-   *     if (!ec)
-   *       if (!sock_.native_non_blocking())
-   *         sock_.native_non_blocking(true, ec);
-   *
-   *     if (!ec)
-   *     {
-   *       for (;;)
-   *       {
-   *         // Try the system call.
-   *         errno = 0;
-   *         int n = ::sendfile(sock_.native_handle(), fd_, &offset_, 65536);
-   *         ec = boost::system::error_code(n < 0 ? errno : 0,
-   *             boost::asio::error::get_system_category());
-   *         total_bytes_transferred_ += ec ? 0 : n;
-   *
-   *         // Retry operation immediately if interrupted by signal.
-   *         if (ec == boost::asio::error::interrupted)
-   *           continue;
-   *
-   *         // Check if we need to run the operation again.
-   *         if (ec == boost::asio::error::would_block
-   *             || ec == boost::asio::error::try_again)
-   *         {
-   *           // We have to wait for the socket to become ready again.
-   *           sock_.async_write_some(boost::asio::null_buffers(), *this);
-   *           return;
-   *         }
-   *
-   *         if (ec || n == 0)
-   *         {
-   *           // An error occurred, or we have reached the end of the file.
-   *           // Either way we must exit the loop so we can call the handler.
-   *           break;
-   *         }
-   *
-   *         // Loop around to try calling sendfile again.
-   *       }
-   *     }
-   *
-   *     // Pass result back to user's handler.
-   *     handler_(ec, total_bytes_transferred_);
-   *   }
-   * };
-   *
-   * template <typename Handler>
-   * void async_sendfile(tcp::socket& sock, int fd, Handler h)
-   * {
-   *   sendfile_op<Handler> op = { sock, fd, h, 0, 0 };
-   *   sock.async_write_some(boost::asio::null_buffers(), op);
-   * } @endcode
-   */
-  void native_non_blocking(bool mode)
-  {
-    boost::system::error_code ec;
-    this->get_service().native_non_blocking(
-        this->get_implementation(), mode, ec);
-    boost::asio::detail::throw_error(ec, "native_non_blocking");
-  }
-
-  /// Sets the non-blocking mode of the native socket implementation.
-  /**
-   * This function is used to modify the non-blocking mode of the underlying
-   * native socket. It has no effect on the behaviour of the socket object's
-   * synchronous operations.
-   *
-   * @param mode If @c true, the underlying socket is put into non-blocking
-   * mode and direct system calls may fail with boost::asio::error::would_block
-   * (or the equivalent system error).
-   *
-   * @param ec Set to indicate what error occurred, if any. If the @c mode is
-   * @c false, but the current value of @c non_blocking() is @c true, this
-   * function fails with boost::asio::error::invalid_argument, as the
-   * combination does not make sense.
-   *
-   * @par Example
-   * This function is intended to allow the encapsulation of arbitrary
-   * non-blocking system calls as asynchronous operations, in a way that is
-   * transparent to the user of the socket object. The following example
-   * illustrates how Linux's @c sendfile system call might be encapsulated:
-   * @code template <typename Handler>
-   * struct sendfile_op
-   * {
-   *   tcp::socket& sock_;
-   *   int fd_;
-   *   Handler handler_;
-   *   off_t offset_;
-   *   std::size_t total_bytes_transferred_;
-   *
-   *   // Function call operator meeting WriteHandler requirements.
-   *   // Used as the handler for the async_write_some operation.
-   *   void operator()(boost::system::error_code ec, std::size_t)
-   *   {
-   *     // Put the underlying socket into non-blocking mode.
-   *     if (!ec)
-   *       if (!sock_.native_non_blocking())
-   *         sock_.native_non_blocking(true, ec);
-   *
-   *     if (!ec)
-   *     {
-   *       for (;;)
-   *       {
-   *         // Try the system call.
-   *         errno = 0;
-   *         int n = ::sendfile(sock_.native_handle(), fd_, &offset_, 65536);
-   *         ec = boost::system::error_code(n < 0 ? errno : 0,
-   *             boost::asio::error::get_system_category());
-   *         total_bytes_transferred_ += ec ? 0 : n;
-   *
-   *         // Retry operation immediately if interrupted by signal.
-   *         if (ec == boost::asio::error::interrupted)
-   *           continue;
-   *
-   *         // Check if we need to run the operation again.
-   *         if (ec == boost::asio::error::would_block
-   *             || ec == boost::asio::error::try_again)
-   *         {
-   *           // We have to wait for the socket to become ready again.
-   *           sock_.async_write_some(boost::asio::null_buffers(), *this);
-   *           return;
-   *         }
-   *
-   *         if (ec || n == 0)
-   *         {
-   *           // An error occurred, or we have reached the end of the file.
-   *           // Either way we must exit the loop so we can call the handler.
-   *           break;
-   *         }
-   *
-   *         // Loop around to try calling sendfile again.
-   *       }
-   *     }
-   *
-   *     // Pass result back to user's handler.
-   *     handler_(ec, total_bytes_transferred_);
-   *   }
-   * };
-   *
-   * template <typename Handler>
-   * void async_sendfile(tcp::socket& sock, int fd, Handler h)
-   * {
-   *   sendfile_op<Handler> op = { sock, fd, h, 0, 0 };
-   *   sock.async_write_some(boost::asio::null_buffers(), op);
-   * } @endcode
-   */
-  boost::system::error_code native_non_blocking(
-      bool mode, boost::system::error_code& ec)
-  {
-    return this->get_service().native_non_blocking(
-        this->get_implementation(), mode, ec);
+    return this->service.io_control(this->implementation, command, ec);
   }
 
   /// Get the local endpoint of the socket.
   /**
    * This function is used to obtain the locally bound endpoint of the socket.
    *
    * @returns An object that represents the local endpoint of the socket.
    *
    * @throws boost::system::system_error Thrown on failure.
    *
    * @par Example
    * @code
    * boost::asio::ip::tcp::socket socket(io_service);
    * ...
    * boost::asio::ip::tcp::endpoint endpoint = socket.local_endpoint();
    * @endcode
    */
   endpoint_type local_endpoint() const
   {
     boost::system::error_code ec;
-    endpoint_type ep = this->get_service().local_endpoint(
-        this->get_implementation(), ec);
-    boost::asio::detail::throw_error(ec, "local_endpoint");
+    endpoint_type ep = this->service.local_endpoint(this->implementation, ec);
+    boost::asio::detail::throw_error(ec);
     return ep;
   }
 
   /// Get the local endpoint of the socket.
   /**
    * This function is used to obtain the locally bound endpoint of the socket.
    *
    * @param ec Set to indicate what error occurred, if any.
    *
    * @returns An object that represents the local endpoint of the socket.
    * Returns a default-constructed endpoint object if an error occurred.
    *
    * @par Example
    * @code
    * boost::asio::ip::tcp::socket socket(io_service);
    * ...
    * boost::system::error_code ec;
    * boost::asio::ip::tcp::endpoint endpoint = socket.local_endpoint(ec);
    * if (ec)
    * {
    *   // An error occurred.
    * }
    * @endcode
    */
   endpoint_type local_endpoint(boost::system::error_code& ec) const
   {
-    return this->get_service().local_endpoint(this->get_implementation(), ec);
+    return this->service.local_endpoint(this->implementation, ec);
   }
 
   /// Get the remote endpoint of the socket.
   /**
    * This function is used to obtain the remote endpoint of the socket.
    *
    * @returns An object that represents the remote endpoint of the socket.
    *
    * @throws boost::system::system_error Thrown on failure.
    *
    * @par Example
    * @code
    * boost::asio::ip::tcp::socket socket(io_service);
    * ...
    * boost::asio::ip::tcp::endpoint endpoint = socket.remote_endpoint();
    * @endcode
    */
   endpoint_type remote_endpoint() const
   {
     boost::system::error_code ec;
-    endpoint_type ep = this->get_service().remote_endpoint(
-        this->get_implementation(), ec);
-    boost::asio::detail::throw_error(ec, "remote_endpoint");
+    endpoint_type ep = this->service.remote_endpoint(this->implementation, ec);
+    boost::asio::detail::throw_error(ec);
     return ep;
   }
 
   /// Get the remote endpoint of the socket.
   /**
    * This function is used to obtain the remote endpoint of the socket.
    *
    * @param ec Set to indicate what error occurred, if any.
    *
    * @returns An object that represents the remote endpoint of the socket.
    * Returns a default-constructed endpoint object if an error occurred.
    *
    * @par Example
    * @code
    * boost::asio::ip::tcp::socket socket(io_service);
    * ...
    * boost::system::error_code ec;
    * boost::asio::ip::tcp::endpoint endpoint = socket.remote_endpoint(ec);
    * if (ec)
    * {
    *   // An error occurred.
    * }
    * @endcode
    */
   endpoint_type remote_endpoint(boost::system::error_code& ec) const
   {
-    return this->get_service().remote_endpoint(this->get_implementation(), ec);
+    return this->service.remote_endpoint(this->implementation, ec);
   }
 
   /// Disable sends or receives on the socket.
   /**
    * This function is used to disable send operations, receive operations, or
    * both.
    *
    * @param what Determines what types of operation will no longer be allowed.
    *
    * @throws boost::system::system_error Thrown on failure.
    *
    * @par Example
    * Shutting down the send side of the socket:
    * @code
    * boost::asio::ip::tcp::socket socket(io_service);
    * ...
    * socket.shutdown(boost::asio::ip::tcp::socket::shutdown_send);
    * @endcode
    */
   void shutdown(shutdown_type what)
   {
     boost::system::error_code ec;
-    this->get_service().shutdown(this->get_implementation(), what, ec);
-    boost::asio::detail::throw_error(ec, "shutdown");
+    this->service.shutdown(this->implementation, what, ec);
+    boost::asio::detail::throw_error(ec);
   }
 
   /// Disable sends or receives on the socket.
   /**
    * This function is used to disable send operations, receive operations, or
    * both.
    *
    * @param what Determines what types of operation will no longer be allowed.
    *
    * @param ec Set to indicate what error occurred, if any.
    *
    * @par Example
    * Shutting down the send side of the socket:
    * @code
    * boost::asio::ip::tcp::socket socket(io_service);
    * ...
    * boost::system::error_code ec;
    * socket.shutdown(boost::asio::ip::tcp::socket::shutdown_send, ec);
    * if (ec)
    * {
    *   // An error occurred.
    * }
    * @endcode
    */
   boost::system::error_code shutdown(shutdown_type what,
       boost::system::error_code& ec)
   {
-    return this->get_service().shutdown(this->get_implementation(), what, ec);
+    return this->service.shutdown(this->implementation, what, ec);
   }
 
 protected:
   /// Protected destructor to prevent deletion through this type.
   ~basic_socket()
   {
   }
 };
 
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // BOOST_ASIO_BASIC_SOCKET_HPP
diff --git a/3rdParty/Boost/src/boost/asio/basic_socket_acceptor.hpp b/3rdParty/Boost/src/boost/asio/basic_socket_acceptor.hpp
index 5a3b0f7..a877bc3 100644
--- a/3rdParty/Boost/src/boost/asio/basic_socket_acceptor.hpp
+++ b/3rdParty/Boost/src/boost/asio/basic_socket_acceptor.hpp
@@ -1,1077 +1,827 @@
 //
 // basic_socket_acceptor.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_BASIC_SOCKET_ACCEPTOR_HPP
 #define BOOST_ASIO_BASIC_SOCKET_ACCEPTOR_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/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/error.hpp>
 #include <boost/asio/socket_acceptor_service.hpp>
 #include <boost/asio/socket_base.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 
 /// Provides the ability to accept new connections.
 /**
  * The basic_socket_acceptor class template is used for accepting new socket
  * connections.
  *
  * @par Thread Safety
  * @e Distinct @e objects: Safe.@n
  * @e Shared @e objects: Unsafe.
  *
  * @par Example
  * Opening a socket acceptor with the SO_REUSEADDR option enabled:
  * @code
  * boost::asio::ip::tcp::acceptor acceptor(io_service);
  * boost::asio::ip::tcp::endpoint endpoint(boost::asio::ip::tcp::v4(), port);
  * acceptor.open(endpoint.protocol());
  * acceptor.set_option(boost::asio::ip::tcp::acceptor::reuse_address(true));
  * acceptor.bind(endpoint);
  * acceptor.listen();
  * @endcode
  */
 template <typename Protocol,
     typename SocketAcceptorService = socket_acceptor_service<Protocol> >
 class basic_socket_acceptor
   : public basic_io_object<SocketAcceptorService>,
     public socket_base
 {
 public:
-  /// (Deprecated: Use native_handle_type.) The native representation of an
-  /// acceptor.
-  typedef typename SocketAcceptorService::native_handle_type native_type;
-
   /// The native representation of an acceptor.
-  typedef typename SocketAcceptorService::native_handle_type native_handle_type;
+  typedef typename SocketAcceptorService::native_type native_type;
 
   /// The protocol type.
   typedef Protocol protocol_type;
 
   /// The endpoint type.
   typedef typename Protocol::endpoint endpoint_type;
 
   /// Construct an acceptor without opening it.
   /**
    * This constructor creates an acceptor without opening it to listen for new
    * connections. The open() function must be called before the acceptor can
    * accept new socket connections.
    *
    * @param io_service The io_service object that the acceptor will use to
    * dispatch handlers for any asynchronous operations performed on the
    * acceptor.
    */
   explicit basic_socket_acceptor(boost::asio::io_service& io_service)
     : basic_io_object<SocketAcceptorService>(io_service)
   {
   }
 
   /// Construct an open acceptor.
   /**
    * This constructor creates an acceptor and automatically opens it.
    *
    * @param io_service The io_service object that the acceptor will use to
    * dispatch handlers for any asynchronous operations performed on the
    * acceptor.
    *
    * @param protocol An object specifying protocol parameters to be used.
    *
    * @throws boost::system::system_error Thrown on failure.
    */
   basic_socket_acceptor(boost::asio::io_service& io_service,
       const protocol_type& protocol)
     : basic_io_object<SocketAcceptorService>(io_service)
   {
     boost::system::error_code ec;
-    this->get_service().open(this->get_implementation(), protocol, ec);
-    boost::asio::detail::throw_error(ec, "open");
+    this->service.open(this->implementation, protocol, ec);
+    boost::asio::detail::throw_error(ec);
   }
 
   /// Construct an acceptor opened on the given endpoint.
   /**
    * This constructor creates an acceptor and automatically opens it to listen
    * for new connections on the specified endpoint.
    *
    * @param io_service The io_service object that the acceptor will use to
    * dispatch handlers for any asynchronous operations performed on the
    * acceptor.
    *
    * @param endpoint An endpoint on the local machine on which the acceptor
    * will listen for new connections.
    *
    * @param reuse_addr Whether the constructor should set the socket option
    * socket_base::reuse_address.
    *
    * @throws boost::system::system_error Thrown on failure.
    *
    * @note This constructor is equivalent to the following code:
    * @code
    * basic_socket_acceptor<Protocol> acceptor(io_service);
    * acceptor.open(endpoint.protocol());
    * if (reuse_addr)
    *   acceptor.set_option(socket_base::reuse_address(true));
    * acceptor.bind(endpoint);
    * acceptor.listen(listen_backlog);
    * @endcode
    */
   basic_socket_acceptor(boost::asio::io_service& io_service,
       const endpoint_type& endpoint, bool reuse_addr = true)
     : basic_io_object<SocketAcceptorService>(io_service)
   {
     boost::system::error_code ec;
-    const protocol_type protocol = endpoint.protocol();
-    this->get_service().open(this->get_implementation(), protocol, ec);
-    boost::asio::detail::throw_error(ec, "open");
+    this->service.open(this->implementation, endpoint.protocol(), ec);
+    boost::asio::detail::throw_error(ec);
     if (reuse_addr)
     {
-      this->get_service().set_option(this->get_implementation(),
+      this->service.set_option(this->implementation,
           socket_base::reuse_address(true), ec);
-      boost::asio::detail::throw_error(ec, "set_option");
+      boost::asio::detail::throw_error(ec);
     }
-    this->get_service().bind(this->get_implementation(), endpoint, ec);
-    boost::asio::detail::throw_error(ec, "bind");
-    this->get_service().listen(this->get_implementation(),
+    this->service.bind(this->implementation, endpoint, ec);
+    boost::asio::detail::throw_error(ec);
+    this->service.listen(this->implementation,
         socket_base::max_connections, ec);
-    boost::asio::detail::throw_error(ec, "listen");
+    boost::asio::detail::throw_error(ec);
   }
 
   /// Construct a basic_socket_acceptor on an existing native acceptor.
   /**
    * This constructor creates an acceptor object to hold an existing native
    * acceptor.
    *
    * @param io_service The io_service object that the acceptor will use to
    * dispatch handlers for any asynchronous operations performed on the
    * acceptor.
    *
    * @param protocol An object specifying protocol parameters to be used.
    *
    * @param native_acceptor A native acceptor.
    *
    * @throws boost::system::system_error Thrown on failure.
    */
   basic_socket_acceptor(boost::asio::io_service& io_service,
-      const protocol_type& protocol, const native_handle_type& native_acceptor)
+      const protocol_type& protocol, const native_type& native_acceptor)
     : basic_io_object<SocketAcceptorService>(io_service)
   {
     boost::system::error_code ec;
-    this->get_service().assign(this->get_implementation(),
-        protocol, native_acceptor, ec);
-    boost::asio::detail::throw_error(ec, "assign");
-  }
-
-#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
-  /// Move-construct a basic_socket_acceptor from another.
-  /**
-   * 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_acceptor(io_service&) constructor.
-   */
-  basic_socket_acceptor(basic_socket_acceptor&& other)
-    : basic_io_object<SocketAcceptorService>(
-        BOOST_ASIO_MOVE_CAST(basic_socket_acceptor)(other))
-  {
+    this->service.assign(this->implementation, protocol, native_acceptor, ec);
+    boost::asio::detail::throw_error(ec);
   }
 
-  /// Move-assign a basic_socket_acceptor from another.
-  /**
-   * 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_acceptor(io_service&) constructor.
-   */
-  basic_socket_acceptor& operator=(basic_socket_acceptor&& other)
-  {
-    basic_io_object<SocketAcceptorService>::operator=(
-        BOOST_ASIO_MOVE_CAST(basic_socket_acceptor)(other));
-    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.
    *
    * @param protocol An object specifying which protocol is to be used.
    *
    * @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());
    * @endcode
    */
   void open(const protocol_type& protocol = protocol_type())
   {
     boost::system::error_code ec;
-    this->get_service().open(this->get_implementation(), protocol, ec);
-    boost::asio::detail::throw_error(ec, "open");
+    this->service.open(this->implementation, protocol, ec);
+    boost::asio::detail::throw_error(ec);
   }
 
   /// Open the acceptor using the specified protocol.
   /**
    * This function opens the socket acceptor so that it will use the specified
    * protocol.
    *
    * @param protocol An object specifying which protocol is to be used.
    *
    * @param ec Set to indicate what error occurred, if any.
    *
    * @par Example
    * @code
    * boost::asio::ip::tcp::acceptor acceptor(io_service);
    * boost::system::error_code ec;
    * acceptor.open(boost::asio::ip::tcp::v4(), ec);
    * if (ec)
    * {
    *   // An error occurred.
    * }
    * @endcode
    */
   boost::system::error_code open(const protocol_type& protocol,
       boost::system::error_code& ec)
   {
-    return this->get_service().open(this->get_implementation(), protocol, ec);
+    return this->service.open(this->implementation, protocol, ec);
   }
 
   /// Assigns an existing native acceptor to the acceptor.
   /*
    * This function opens the acceptor to hold an existing native acceptor.
    *
    * @param protocol An object specifying which protocol is to be used.
    *
    * @param native_acceptor A native acceptor.
    *
    * @throws boost::system::system_error Thrown on failure.
    */
-  void assign(const protocol_type& protocol,
-      const native_handle_type& native_acceptor)
+  void assign(const protocol_type& protocol, const native_type& native_acceptor)
   {
     boost::system::error_code ec;
-    this->get_service().assign(this->get_implementation(),
-        protocol, native_acceptor, ec);
-    boost::asio::detail::throw_error(ec, "assign");
+    this->service.assign(this->implementation, protocol, native_acceptor, ec);
+    boost::asio::detail::throw_error(ec);
   }
 
   /// Assigns an existing native acceptor to the acceptor.
   /*
    * This function opens the acceptor to hold an existing native acceptor.
    *
    * @param protocol An object specifying which protocol is to be used.
    *
    * @param native_acceptor A native acceptor.
    *
    * @param ec Set to indicate what error occurred, if any.
    */
   boost::system::error_code assign(const protocol_type& protocol,
-      const native_handle_type& native_acceptor, boost::system::error_code& ec)
+      const native_type& native_acceptor, boost::system::error_code& ec)
   {
-    return this->get_service().assign(this->get_implementation(),
+    return this->service.assign(this->implementation,
         protocol, native_acceptor, ec);
   }
 
   /// Determine whether the acceptor is open.
   bool is_open() const
   {
-    return this->get_service().is_open(this->get_implementation());
+    return this->service.is_open(this->implementation);
   }
 
   /// Bind the acceptor to the given local endpoint.
   /**
    * This function binds the socket acceptor to the specified endpoint on the
    * local machine.
    *
    * @param endpoint An endpoint on the local machine to which the socket
    * acceptor will be bound.
    *
    * @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));
    * @endcode
    */
   void bind(const endpoint_type& endpoint)
   {
     boost::system::error_code ec;
-    this->get_service().bind(this->get_implementation(), endpoint, ec);
-    boost::asio::detail::throw_error(ec, "bind");
+    this->service.bind(this->implementation, endpoint, ec);
+    boost::asio::detail::throw_error(ec);
   }
 
   /// Bind the acceptor to the given local endpoint.
   /**
    * This function binds the socket acceptor to the specified endpoint on the
    * local machine.
    *
    * @param endpoint An endpoint on the local machine to which the socket
    * acceptor will be bound.
    *
    * @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::system::error_code ec;
    * acceptor.bind(boost::asio::ip::tcp::endpoint(12345), ec);
    * if (ec)
    * {
    *   // An error occurred.
    * }
    * @endcode
    */
   boost::system::error_code bind(const endpoint_type& endpoint,
       boost::system::error_code& ec)
   {
-    return this->get_service().bind(this->get_implementation(), endpoint, ec);
+    return this->service.bind(this->implementation, endpoint, ec);
   }
 
   /// Place the acceptor into the state where it will listen for new
   /// connections.
   /**
    * This function puts the socket acceptor into the state where it may accept
    * new connections.
    *
    * @param backlog The maximum length of the queue of pending connections.
    *
    * @throws boost::system::system_error Thrown on failure.
    */
   void listen(int backlog = socket_base::max_connections)
   {
     boost::system::error_code ec;
-    this->get_service().listen(this->get_implementation(), backlog, ec);
-    boost::asio::detail::throw_error(ec, "listen");
+    this->service.listen(this->implementation, backlog, ec);
+    boost::asio::detail::throw_error(ec);
   }
 
   /// Place the acceptor into the state where it will listen for new
   /// connections.
   /**
    * This function puts the socket acceptor into the state where it may accept
    * new connections.
    *
    * @param backlog The maximum length of the queue of pending connections.
    *
    * @param ec Set to indicate what error occurred, if any.
    *
    * @par Example
    * @code
    * boost::asio::ip::tcp::acceptor acceptor(io_service);
    * ...
    * boost::system::error_code ec;
    * acceptor.listen(boost::asio::socket_base::max_connections, ec);
    * if (ec)
    * {
    *   // An error occurred.
    * }
    * @endcode
    */
   boost::system::error_code listen(int backlog, boost::system::error_code& ec)
   {
-    return this->get_service().listen(this->get_implementation(), backlog, ec);
+    return this->service.listen(this->implementation, backlog, ec);
   }
 
   /// Close the acceptor.
   /**
    * This function is used to close the acceptor. Any asynchronous accept
    * operations will be cancelled immediately.
    *
    * A subsequent call to open() is required before the acceptor can again be
    * used to again perform socket accept operations.
    *
    * @throws boost::system::system_error Thrown on failure.
    */
   void close()
   {
     boost::system::error_code ec;
-    this->get_service().close(this->get_implementation(), ec);
-    boost::asio::detail::throw_error(ec, "close");
+    this->service.close(this->implementation, ec);
+    boost::asio::detail::throw_error(ec);
   }
 
   /// Close the acceptor.
   /**
    * This function is used to close the acceptor. Any asynchronous accept
    * operations will be cancelled immediately.
    *
    * A subsequent call to open() is required before the acceptor can again be
    * used to again perform socket accept operations.
    *
    * @param ec Set to indicate what error occurred, if any.
    *
    * @par Example
    * @code
    * boost::asio::ip::tcp::acceptor acceptor(io_service);
    * ...
    * boost::system::error_code ec;
    * acceptor.close(ec);
    * if (ec)
    * {
    *   // An error occurred.
    * }
    * @endcode
    */
   boost::system::error_code close(boost::system::error_code& ec)
   {
-    return this->get_service().close(this->get_implementation(), ec);
-  }
-
-  /// (Deprecated: Use native_handle().) Get the native acceptor representation.
-  /**
-   * This function may be used to obtain the underlying representation of the
-   * acceptor. This is intended to allow access to native acceptor functionality
-   * that is not otherwise provided.
-   */
-  native_type native()
-  {
-    return this->get_service().native_handle(this->get_implementation());
+    return this->service.close(this->implementation, ec);
   }
 
   /// Get the native acceptor representation.
   /**
    * This function may be used to obtain the underlying representation of the
    * acceptor. This is intended to allow access to native acceptor functionality
    * that is not otherwise provided.
    */
-  native_handle_type native_handle()
+  native_type native()
   {
-    return this->get_service().native_handle(this->get_implementation());
+    return this->service.native(this->implementation);
   }
 
   /// Cancel all asynchronous operations associated with the acceptor.
   /**
    * This function causes all outstanding asynchronous connect, send and receive
    * operations to finish immediately, and the handlers for cancelled operations
    * will be passed the boost::asio::error::operation_aborted error.
    *
    * @throws boost::system::system_error Thrown on failure.
    */
   void cancel()
   {
     boost::system::error_code ec;
-    this->get_service().cancel(this->get_implementation(), ec);
-    boost::asio::detail::throw_error(ec, "cancel");
+    this->service.cancel(this->implementation, ec);
+    boost::asio::detail::throw_error(ec);
   }
 
   /// Cancel all asynchronous operations associated with the acceptor.
   /**
    * This function causes all outstanding asynchronous connect, send and receive
    * operations to finish immediately, and the handlers for cancelled operations
    * will be passed the boost::asio::error::operation_aborted error.
    *
    * @param ec Set to indicate what error occurred, if any.
    */
   boost::system::error_code cancel(boost::system::error_code& ec)
   {
-    return this->get_service().cancel(this->get_implementation(), ec);
+    return this->service.cancel(this->implementation, ec);
   }
 
   /// Set an option on the acceptor.
   /**
    * This function is used to set an option on the acceptor.
    *
    * @param option The new option value to be set on the acceptor.
    *
    * @throws boost::system::system_error Thrown on failure.
    *
    * @sa SettableSocketOption @n
    * boost::asio::socket_base::reuse_address
    * boost::asio::socket_base::enable_connection_aborted
    *
    * @par Example
    * Setting the SOL_SOCKET/SO_REUSEADDR option:
    * @code
    * boost::asio::ip::tcp::acceptor acceptor(io_service);
    * ...
    * boost::asio::ip::tcp::acceptor::reuse_address option(true);
    * acceptor.set_option(option);
    * @endcode
    */
   template <typename SettableSocketOption>
   void set_option(const SettableSocketOption& option)
   {
     boost::system::error_code ec;
-    this->get_service().set_option(this->get_implementation(), option, ec);
-    boost::asio::detail::throw_error(ec, "set_option");
+    this->service.set_option(this->implementation, option, ec);
+    boost::asio::detail::throw_error(ec);
   }
 
   /// Set an option on the acceptor.
   /**
    * This function is used to set an option on the acceptor.
    *
    * @param option The new option value to be set on the acceptor.
    *
    * @param ec Set to indicate what error occurred, if any.
    *
    * @sa SettableSocketOption @n
    * boost::asio::socket_base::reuse_address
    * boost::asio::socket_base::enable_connection_aborted
    *
    * @par Example
    * Setting the SOL_SOCKET/SO_REUSEADDR option:
    * @code
    * boost::asio::ip::tcp::acceptor acceptor(io_service);
    * ...
    * boost::asio::ip::tcp::acceptor::reuse_address option(true);
    * boost::system::error_code ec;
    * acceptor.set_option(option, ec);
    * if (ec)
    * {
    *   // An error occurred.
    * }
    * @endcode
    */
   template <typename SettableSocketOption>
   boost::system::error_code set_option(const SettableSocketOption& option,
       boost::system::error_code& ec)
   {
-    return this->get_service().set_option(
-        this->get_implementation(), option, ec);
+    return this->service.set_option(this->implementation, option, ec);
   }
 
   /// Get an option from the acceptor.
   /**
    * This function is used to get the current value of an option on the
    * acceptor.
    *
    * @param option The option value to be obtained from the acceptor.
    *
    * @throws boost::system::system_error Thrown on failure.
    *
    * @sa GettableSocketOption @n
    * boost::asio::socket_base::reuse_address
    *
    * @par Example
    * Getting the value of the SOL_SOCKET/SO_REUSEADDR option:
    * @code
    * boost::asio::ip::tcp::acceptor acceptor(io_service);
    * ...
    * boost::asio::ip::tcp::acceptor::reuse_address option;
    * acceptor.get_option(option);
    * bool is_set = option.get();
    * @endcode
    */
   template <typename GettableSocketOption>
   void get_option(GettableSocketOption& option)
   {
     boost::system::error_code ec;
-    this->get_service().get_option(this->get_implementation(), option, ec);
-    boost::asio::detail::throw_error(ec, "get_option");
+    this->service.get_option(this->implementation, option, ec);
+    boost::asio::detail::throw_error(ec);
   }
 
   /// Get an option from the acceptor.
   /**
    * This function is used to get the current value of an option on the
    * acceptor.
    *
    * @param option The option value to be obtained from the acceptor.
    *
    * @param ec Set to indicate what error occurred, if any.
    *
    * @sa GettableSocketOption @n
    * boost::asio::socket_base::reuse_address
    *
    * @par Example
    * Getting the value of the SOL_SOCKET/SO_REUSEADDR option:
    * @code
    * boost::asio::ip::tcp::acceptor acceptor(io_service);
    * ...
    * boost::asio::ip::tcp::acceptor::reuse_address option;
    * boost::system::error_code ec;
    * acceptor.get_option(option, ec);
    * if (ec)
    * {
    *   // An error occurred.
    * }
    * bool is_set = option.get();
    * @endcode
    */
   template <typename GettableSocketOption>
   boost::system::error_code get_option(GettableSocketOption& option,
       boost::system::error_code& ec)
   {
-    return this->get_service().get_option(
-        this->get_implementation(), option, ec);
-  }
-
-  /// Perform an IO control command on the acceptor.
-  /**
-   * This function is used to execute an IO control command on the acceptor.
-   *
-   * @param command The IO control command to be performed on the acceptor.
-   *
-   * @throws boost::system::system_error Thrown on failure.
-   *
-   * @sa IoControlCommand @n
-   * boost::asio::socket_base::non_blocking_io
-   *
-   * @par Example
-   * Getting the number of bytes ready to read:
-   * @code
-   * boost::asio::ip::tcp::acceptor acceptor(io_service);
-   * ...
-   * boost::asio::ip::tcp::acceptor::non_blocking_io command(true);
-   * socket.io_control(command);
-   * @endcode
-   */
-  template <typename IoControlCommand>
-  void io_control(IoControlCommand& command)
-  {
-    boost::system::error_code ec;
-    this->get_service().io_control(this->get_implementation(), command, ec);
-    boost::asio::detail::throw_error(ec, "io_control");
-  }
-
-  /// Perform an IO control command on the acceptor.
-  /**
-   * This function is used to execute an IO control command on the acceptor.
-   *
-   * @param command The IO control command to be performed on the acceptor.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @sa IoControlCommand @n
-   * boost::asio::socket_base::non_blocking_io
-   *
-   * @par Example
-   * Getting the number of bytes ready to read:
-   * @code
-   * boost::asio::ip::tcp::acceptor acceptor(io_service);
-   * ...
-   * boost::asio::ip::tcp::acceptor::non_blocking_io command(true);
-   * boost::system::error_code ec;
-   * socket.io_control(command, ec);
-   * if (ec)
-   * {
-   *   // An error occurred.
-   * }
-   * @endcode
-   */
-  template <typename IoControlCommand>
-  boost::system::error_code io_control(IoControlCommand& command,
-      boost::system::error_code& ec)
-  {
-    return this->get_service().io_control(
-        this->get_implementation(), command, ec);
-  }
-
-  /// Gets the non-blocking mode of the acceptor.
-  /**
-   * @returns @c true if the acceptor's synchronous operations will fail with
-   * boost::asio::error::would_block if they are unable to perform the requested
-   * operation immediately. If @c false, synchronous operations will block
-   * until complete.
-   *
-   * @note The non-blocking mode has no effect on the behaviour of asynchronous
-   * operations. Asynchronous operations will never fail with the error
-   * boost::asio::error::would_block.
-   */
-  bool non_blocking() const
-  {
-    return this->get_service().non_blocking(this->get_implementation());
-  }
-
-  /// Sets the non-blocking mode of the acceptor.
-  /**
-   * @param mode If @c true, the acceptor's synchronous operations will fail
-   * with boost::asio::error::would_block if they are unable to perform the
-   * requested operation immediately. If @c false, synchronous operations will
-   * block until complete.
-   *
-   * @throws boost::system::system_error Thrown on failure.
-   *
-   * @note The non-blocking mode has no effect on the behaviour of asynchronous
-   * operations. Asynchronous operations will never fail with the error
-   * boost::asio::error::would_block.
-   */
-  void non_blocking(bool mode)
-  {
-    boost::system::error_code ec;
-    this->get_service().non_blocking(this->get_implementation(), mode, ec);
-    boost::asio::detail::throw_error(ec, "non_blocking");
-  }
-
-  /// Sets the non-blocking mode of the acceptor.
-  /**
-   * @param mode If @c true, the acceptor's synchronous operations will fail
-   * with boost::asio::error::would_block if they are unable to perform the
-   * requested operation immediately. If @c false, synchronous operations will
-   * block until complete.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @note The non-blocking mode has no effect on the behaviour of asynchronous
-   * operations. Asynchronous operations will never fail with the error
-   * boost::asio::error::would_block.
-   */
-  boost::system::error_code non_blocking(
-      bool mode, boost::system::error_code& ec)
-  {
-    return this->get_service().non_blocking(
-        this->get_implementation(), mode, ec);
-  }
-
-  /// Gets the non-blocking mode of the native acceptor implementation.
-  /**
-   * This function is used to retrieve the non-blocking mode of the underlying
-   * native acceptor. This mode has no effect on the behaviour of the acceptor
-   * object's synchronous operations.
-   *
-   * @returns @c true if the underlying acceptor is in non-blocking mode and
-   * direct system calls may fail with boost::asio::error::would_block (or the
-   * equivalent system error).
-   *
-   * @note The current non-blocking mode is cached by the acceptor object.
-   * Consequently, the return value may be incorrect if the non-blocking mode
-   * was set directly on the native acceptor.
-   */
-  bool native_non_blocking() const
-  {
-    return this->get_service().native_non_blocking(this->get_implementation());
-  }
-
-  /// Sets the non-blocking mode of the native acceptor implementation.
-  /**
-   * This function is used to modify the non-blocking mode of the underlying
-   * native acceptor. It has no effect on the behaviour of the acceptor object's
-   * synchronous operations.
-   *
-   * @param mode If @c true, the underlying acceptor is put into non-blocking
-   * mode and direct system calls may fail with boost::asio::error::would_block
-   * (or the equivalent system error).
-   *
-   * @throws boost::system::system_error Thrown on failure. If the @c mode is
-   * @c false, but the current value of @c non_blocking() is @c true, this
-   * function fails with boost::asio::error::invalid_argument, as the
-   * combination does not make sense.
-   */
-  void native_non_blocking(bool mode)
-  {
-    boost::system::error_code ec;
-    this->get_service().native_non_blocking(
-        this->get_implementation(), mode, ec);
-    boost::asio::detail::throw_error(ec, "native_non_blocking");
-  }
-
-  /// Sets the non-blocking mode of the native acceptor implementation.
-  /**
-   * This function is used to modify the non-blocking mode of the underlying
-   * native acceptor. It has no effect on the behaviour of the acceptor object's
-   * synchronous operations.
-   *
-   * @param mode If @c true, the underlying acceptor is put into non-blocking
-   * mode and direct system calls may fail with boost::asio::error::would_block
-   * (or the equivalent system error).
-   *
-   * @param ec Set to indicate what error occurred, if any. If the @c mode is
-   * @c false, but the current value of @c non_blocking() is @c true, this
-   * function fails with boost::asio::error::invalid_argument, as the
-   * combination does not make sense.
-   */
-  boost::system::error_code native_non_blocking(
-      bool mode, boost::system::error_code& ec)
-  {
-    return this->get_service().native_non_blocking(
-        this->get_implementation(), mode, ec);
+    return this->service.get_option(this->implementation, option, ec);
   }
 
   /// Get the local endpoint of the acceptor.
   /**
    * This function is used to obtain the locally bound endpoint of the acceptor.
    *
    * @returns An object that represents the local endpoint of the acceptor.
    *
    * @throws boost::system::system_error Thrown on failure.
    *
    * @par Example
    * @code
    * boost::asio::ip::tcp::acceptor acceptor(io_service);
    * ...
    * boost::asio::ip::tcp::endpoint endpoint = acceptor.local_endpoint();
    * @endcode
    */
   endpoint_type local_endpoint() const
   {
     boost::system::error_code ec;
-    endpoint_type ep = this->get_service().local_endpoint(
-        this->get_implementation(), ec);
-    boost::asio::detail::throw_error(ec, "local_endpoint");
+    endpoint_type ep = this->service.local_endpoint(this->implementation, ec);
+    boost::asio::detail::throw_error(ec);
     return ep;
   }
 
   /// Get the local endpoint of the acceptor.
   /**
    * This function is used to obtain the locally bound endpoint of the acceptor.
    *
    * @param ec Set to indicate what error occurred, if any.
    *
    * @returns An object that represents the local endpoint of the acceptor.
    * Returns a default-constructed endpoint object if an error occurred and the
    * error handler did not throw an exception.
    *
    * @par Example
    * @code
    * boost::asio::ip::tcp::acceptor acceptor(io_service);
    * ...
    * boost::system::error_code ec;
    * boost::asio::ip::tcp::endpoint endpoint = acceptor.local_endpoint(ec);
    * if (ec)
    * {
    *   // An error occurred.
    * }
    * @endcode
    */
   endpoint_type local_endpoint(boost::system::error_code& ec) const
   {
-    return this->get_service().local_endpoint(this->get_implementation(), ec);
+    return this->service.local_endpoint(this->implementation, ec);
   }
 
   /// Accept a new connection.
   /**
    * This function is used to accept a new connection from a peer into the
    * given socket. The function call will block until a new connection has been
    * accepted successfully or an error occurs.
    *
    * @param peer The socket into which the new connection will be accepted.
    *
    * @throws boost::system::system_error Thrown on failure.
    *
    * @par Example
    * @code
    * 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)
   {
     boost::system::error_code ec;
-    this->get_service().accept(this->get_implementation(), peer, 0, ec);
-    boost::asio::detail::throw_error(ec, "accept");
+    this->service.accept(this->implementation, peer, 0, ec);
+    boost::asio::detail::throw_error(ec);
   }
 
   /// Accept a new connection.
   /**
    * This function is used to accept a new connection from a peer into the
    * given socket. The function call will block until a new connection has been
    * accepted successfully or an error occurs.
    *
    * @param peer The socket into which the new connection will be accepted.
    *
    * @param ec Set to indicate what error occurred, if any.
    *
    * @par Example
    * @code
    * boost::asio::ip::tcp::acceptor acceptor(io_service);
    * ...
    * boost::asio::ip::tcp::soocket socket(io_service);
    * boost::system::error_code ec;
    * acceptor.accept(socket, ec);
    * if (ec)
    * {
    *   // An error occurred.
    * }
    * @endcode
    */
   template <typename SocketService>
   boost::system::error_code accept(
       basic_socket<protocol_type, SocketService>& peer,
       boost::system::error_code& ec)
   {
-    return this->get_service().accept(this->get_implementation(), peer, 0, ec);
+    return this->service.accept(this->implementation, peer, 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.
    *
    * @param peer The socket into which the new connection will be accepted.
    * Ownership of the peer object is retained by the caller, which must
    * guarantee that it is valid until the handler is called.
    *
    * @param handler The handler to be called when the accept operation
    * completes. Copies will be made of the handler as required. The function
    * signature of the handler must be:
    * @code void handler(
    *   const boost::system::error_code& error // Result of operation.
    * ); @endcode
    * 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().
    *
    * @par Example
    * @code
    * void accept_handler(const boost::system::error_code& error)
    * {
    *   if (!error)
    *   {
    *     // Accept succeeded.
    *   }
    * }
    *
    * ...
    *
    * 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)
+      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, 0, BOOST_ASIO_MOVE_CAST(AcceptHandler)(handler));
+    this->service.async_accept(this->implementation, peer, 0, 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.
    * The function call will block until a new connection has been accepted
    * successfully or an error occurs.
    *
    * @param peer The socket into which the new connection will be accepted.
    *
    * @param peer_endpoint An endpoint object which will receive the endpoint of
    * the remote peer.
    *
    * @throws boost::system::system_error Thrown on failure.
    *
    * @par Example
    * @code
    * boost::asio::ip::tcp::acceptor acceptor(io_service);
    * ...
    * boost::asio::ip::tcp::socket socket(io_service);
    * boost::asio::ip::tcp::endpoint endpoint;
    * acceptor.accept(socket, endpoint);
    * @endcode
    */
   template <typename SocketService>
   void accept(basic_socket<protocol_type, SocketService>& peer,
       endpoint_type& peer_endpoint)
   {
     boost::system::error_code ec;
-    this->get_service().accept(this->get_implementation(),
-        peer, &peer_endpoint, ec);
-    boost::asio::detail::throw_error(ec, "accept");
+    this->service.accept(this->implementation, peer, &peer_endpoint, ec);
+    boost::asio::detail::throw_error(ec);
   }
 
   /// 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.
    * The function call will block until a new connection has been accepted
    * successfully or an error occurs.
    *
    * @param peer The socket into which the new connection will be accepted.
    *
    * @param peer_endpoint An endpoint object which will receive the endpoint of
    * the remote peer.
    *
    * @param ec Set to indicate what error occurred, if any.
    *
    * @par Example
    * @code
    * boost::asio::ip::tcp::acceptor acceptor(io_service);
    * ...
    * boost::asio::ip::tcp::socket socket(io_service);
    * boost::asio::ip::tcp::endpoint endpoint;
    * boost::system::error_code ec;
    * acceptor.accept(socket, endpoint, ec);
    * if (ec)
    * {
    *   // An error occurred.
    * }
    * @endcode
    */
   template <typename SocketService>
   boost::system::error_code accept(
       basic_socket<protocol_type, SocketService>& peer,
       endpoint_type& peer_endpoint, boost::system::error_code& ec)
   {
-    return this->get_service().accept(
-        this->get_implementation(), peer, &peer_endpoint, ec);
+    return this->service.accept(this->implementation, peer, &peer_endpoint, ec);
   }
 
   /// Start an asynchronous accept.
   /**
    * This function is used to asynchronously accept a new connection into a
    * socket, and additionally obtain the endpoint of the remote peer. The
    * function call always returns immediately.
    *
    * @param peer The socket into which the new connection will be accepted.
    * Ownership of the peer object is retained by the caller, which must
    * guarantee that it is valid until the handler is called.
    *
    * @param peer_endpoint An endpoint object into which the endpoint of the
    * remote peer will be written. Ownership of the peer_endpoint object is
    * retained by the caller, which must guarantee that it is valid until the
    * handler is called.
    *
    * @param handler The handler to be called when the accept operation
    * completes. Copies will be made of the handler as required. The function
    * signature of the handler must be:
    * @code void handler(
    *   const boost::system::error_code& error // Result of operation.
    * ); @endcode
    * 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,
-      endpoint_type& peer_endpoint, BOOST_ASIO_MOVE_ARG(AcceptHandler) handler)
+      endpoint_type& peer_endpoint, 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,
-        &peer_endpoint, BOOST_ASIO_MOVE_CAST(AcceptHandler)(handler));
+    this->service.async_accept(this->implementation,
+        peer, &peer_endpoint, handler);
   }
 };
 
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // BOOST_ASIO_BASIC_SOCKET_ACCEPTOR_HPP
diff --git a/3rdParty/Boost/src/boost/asio/basic_socket_iostream.hpp b/3rdParty/Boost/src/boost/asio/basic_socket_iostream.hpp
index 6fae085..142f404 100644
--- a/3rdParty/Boost/src/boost/asio/basic_socket_iostream.hpp
+++ b/3rdParty/Boost/src/boost/asio/basic_socket_iostream.hpp
@@ -1,260 +1,153 @@
 //
 // basic_socket_iostream.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_BASIC_SOCKET_IOSTREAM_HPP
 #define BOOST_ASIO_BASIC_SOCKET_IOSTREAM_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_NO_IOSTREAM)
 
+#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>
 #include <boost/utility/base_from_member.hpp>
 #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)
+#if !defined(BOOST_ASIO_SOCKET_IOSTREAM_MAX_ARITY)
+#define BOOST_ASIO_SOCKET_IOSTREAM_MAX_ARITY 5
+#endif // !defined(BOOST_ASIO_SOCKET_IOSTREAM_MAX_ARITY)
 
 // 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)
+//         basic_socket_streambuf<Protocol, StreamSocketService> >::member)
 //   {
 //     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) \
+#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) \
+        basic_socket_streambuf<Protocol, StreamSocketService> >::member) \
   { \
-    this->setf(std::ios_base::unitbuf); \
+    tie(this); \
     if (rdbuf()->connect(BOOST_PP_ENUM_PARAMS(n, x)) == 0) \
       this->setstate(std::ios_base::failbit); \
   } \
   /**/
 
 // A macro that should expand to:
 //   template <typename T1, ..., typename Tn>
 //   void connect(T1 x1, ..., Tn xn)
 //   {
 //     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) \
+#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)) \
   { \
     if (rdbuf()->connect(BOOST_PP_ENUM_PARAMS(n, x)) == 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 {
 
 /// Iostream interface for a socket.
 template <typename Protocol,
-    typename StreamSocketService = stream_socket_service<Protocol>,
-    typename Time = boost::posix_time::ptime,
-    typename TimeTraits = boost::asio::time_traits<Time>,
-    typename TimerService = deadline_timer_service<Time, TimeTraits> >
+    typename StreamSocketService = stream_socket_service<Protocol> >
 class basic_socket_iostream
   : public boost::base_from_member<
-      basic_socket_streambuf<Protocol, StreamSocketService,
-        Time, TimeTraits, TimerService> >,
+      basic_socket_streambuf<Protocol, StreamSocketService> >,
     public std::basic_iostream<char>
 {
 public:
-  /// The endpoint type.
-  typedef typename Protocol::endpoint endpoint_type;
-
-  /// The time type.
-  typedef typename TimeTraits::time_type time_type;
-
-  /// The duration type.
-  typedef typename TimeTraits::duration_type duration_type;
-
   /// 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)
+        basic_socket_streambuf<Protocol, StreamSocketService> >::member)
   {
-    this->setf(std::ios_base::unitbuf);
+    tie(this);
   }
 
 #if defined(GENERATING_DOCUMENTATION)
   /// Establish a connection to an endpoint corresponding to a resolver query.
   /**
    * This constructor automatically establishes a connection based on the
    * supplied resolver query parameters. The arguments are used to construct
    * a resolver query object.
    */
   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)
-  {
-    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, _ )
 #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
    * resolver query parameters. The arguments are used to construct a resolver
    * query object.
    */
   template <typename T1, ..., typename TN>
   void connect(T1 t1, ..., TN tn);
-#elif defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
-  template <typename... T>
-  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, _ )
 #endif
 
   /// Close the connection.
   void close()
   {
     if (rdbuf()->close() == 0)
       this->setstate(std::ios_base::failbit);
   }
 
   /// Return a pointer to the underlying streambuf.
-  basic_socket_streambuf<Protocol, StreamSocketService,
-    Time, TimeTraits, TimerService>* rdbuf() const
+  basic_socket_streambuf<Protocol, StreamSocketService>* rdbuf() const
   {
-    return const_cast<basic_socket_streambuf<Protocol, StreamSocketService,
-      Time, TimeTraits, TimerService>*>(
+    return const_cast<basic_socket_streambuf<Protocol, StreamSocketService>*>(
         &this->boost::base_from_member<
-          basic_socket_streambuf<Protocol, StreamSocketService,
-            Time, TimeTraits, TimerService> >::member);
-  }
-
-  /// Get the last error associated with the stream.
-  /**
-   * @return An \c error_code corresponding to the last error from the stream.
-   *
-   * @par Example
-   * To print the error associated with a failure to establish a connection:
-   * @code tcp::iostream s("www.boost.org", "http");
-   * if (!s)
-   * {
-   *   std::cout << "Error: " << s.error().message() << std::endl;
-   * } @endcode
-   */
-  const boost::system::error_code& error() const
-  {
-    return rdbuf()->puberror();
-  }
-
-  /// Get the stream's expiry time as an absolute time.
-  /**
-   * @return An absolute time value representing the stream's expiry time.
-   */
-  time_type expires_at() const
-  {
-    return rdbuf()->expires_at();
-  }
-
-  /// Set the stream's expiry time as an absolute time.
-  /**
-   * This function sets the expiry time associated with the stream. Stream
-   * operations performed after this time (where the operations cannot be
-   * completed using the internal buffers) will fail with the error
-   * boost::asio::error::operation_aborted.
-   *
-   * @param expiry_time The expiry time to be used for the stream.
-   */
-  void expires_at(const time_type& expiry_time)
-  {
-    rdbuf()->expires_at(expiry_time);
-  }
-
-  /// Get the timer's expiry time relative to now.
-  /**
-   * @return A relative time value representing the stream's expiry time.
-   */
-  duration_type expires_from_now() const
-  {
-    return rdbuf()->expires_from_now();
-  }
-
-  /// Set the stream'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
-   * completed using the internal buffers) will fail with the error
-   * boost::asio::error::operation_aborted.
-   *
-   * @param expiry_time The expiry time to be used for the timer.
-   */
-  void expires_from_now(const duration_type& expiry_time)
-  {
-    rdbuf()->expires_from_now(expiry_time);
+          basic_socket_streambuf<Protocol, StreamSocketService> >::member);
   }
 };
 
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
-#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)
+#undef BOOST_ASIO_PRIVATE_CTR_DEF
+#undef BOOST_ASIO_PRIVATE_CONNECT_DEF
 
 #endif // defined(BOOST_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..c2a9a99 100644
--- a/3rdParty/Boost/src/boost/asio/basic_socket_streambuf.hpp
+++ b/3rdParty/Boost/src/boost/asio/basic_socket_streambuf.hpp
@@ -1,548 +1,292 @@
 //
 // basic_socket_streambuf.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_BASIC_SOCKET_STREAMBUF_HPP
 #define BOOST_ASIO_BASIC_SOCKET_STREAMBUF_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_NO_IOSTREAM)
 
 #include <streambuf>
+#include <boost/array.hpp>
+#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>
 #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_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)
+#if !defined(BOOST_ASIO_SOCKET_STREAMBUF_MAX_ARITY)
+#define BOOST_ASIO_SOCKET_STREAMBUF_MAX_ARITY 5
+#endif // !defined(BOOST_ASIO_SOCKET_STREAMBUF_MAX_ARITY)
 
 // A macro that should expand to:
 //   template <typename T1, ..., typename Tn>
-//   basic_socket_streambuf<Protocol, StreamSocketService,
-//     Time, TimeTraits, TimerService>* connect(
+//   basic_socket_streambuf<Protocol, StreamSocketService>* connect(
 //       T1 x1, ..., Tn xn)
 //   {
 //     init_buffers();
-//     this->basic_socket<Protocol, StreamSocketService>::close(ec_);
+//     boost::system::error_code ec;
+//     this->basic_socket<Protocol, StreamSocketService>::close(ec);
 //     typedef typename Protocol::resolver resolver_type;
 //     typedef typename resolver_type::query resolver_query;
 //     resolver_query query(x1, ..., xn);
-//     resolve_and_connect(query);
-//     return !ec_ ? this : 0;
+//     resolve_and_connect(query, ec);
+//     return !ec ? this : 0;
 //   }
 // This macro should only persist within this file.
 
-# define BOOST_ASIO_PRIVATE_CONNECT_DEF( z, n, data ) \
+#define BOOST_ASIO_PRIVATE_CONNECT_DEF( z, n, data ) \
   template <BOOST_PP_ENUM_PARAMS(n, typename T)> \
-  basic_socket_streambuf<Protocol, StreamSocketService, \
-    Time, TimeTraits, TimerService>* connect( \
+  basic_socket_streambuf<Protocol, StreamSocketService>* connect( \
       BOOST_PP_ENUM_BINARY_PARAMS(n, T, x)) \
   { \
     init_buffers(); \
-    this->basic_socket<Protocol, StreamSocketService>::close(ec_); \
+    boost::system::error_code ec; \
+    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)); \
-    resolve_and_connect(query); \
-    return !ec_ ? this : 0; \
+    resolve_and_connect(query, ec); \
+    return !ec ? this : 0; \
   } \
   /**/
 
-#endif // !defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
-
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 
 /// Iostream streambuf for a socket.
 template <typename Protocol,
-    typename StreamSocketService = stream_socket_service<Protocol>,
-    typename Time = boost::posix_time::ptime,
-    typename TimeTraits = boost::asio::time_traits<Time>,
-    typename TimerService = deadline_timer_service<Time, TimeTraits> >
+    typename StreamSocketService = stream_socket_service<Protocol> >
 class basic_socket_streambuf
   : public std::streambuf,
     private boost::base_from_member<io_service>,
     public basic_socket<Protocol, StreamSocketService>
 {
 public:
   /// The endpoint type.
   typedef typename Protocol::endpoint endpoint_type;
 
-  /// The time type.
-  typedef typename TimeTraits::time_type time_type;
-
-  /// The duration type.
-  typedef typename TimeTraits::duration_type duration_type;
-
   /// 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),
-      unbuffered_(false),
-      timer_service_(0),
-      timer_state_(no_timer)
+      unbuffered_(false)
   {
     init_buffers();
   }
 
   /// Destructor flushes buffered data.
   virtual ~basic_socket_streambuf()
   {
     if (pptr() != pbase())
       overflow(traits_type::eof());
-
-    destroy_timer();
   }
 
   /// Establish a connection.
   /**
    * This function establishes a connection to the specified endpoint.
    *
    * @return \c this if a connection was successfully established, a null
    * pointer otherwise.
    */
-  basic_socket_streambuf<Protocol, StreamSocketService,
-    Time, TimeTraits, TimerService>* connect(
+  basic_socket_streambuf<Protocol, StreamSocketService>* connect(
       const endpoint_type& endpoint)
   {
     init_buffers();
-
-    this->basic_socket<Protocol, StreamSocketService>::close(ec_);
-
-    if (timer_state_ == timer_has_expired)
-    {
-      ec_ = boost::asio::error::operation_aborted;
-      return 0;
-    }
-
-    io_handler handler = { this };
-    this->basic_socket<Protocol, StreamSocketService>::async_connect(
-        endpoint, handler);
-
-    ec_ = boost::asio::error::would_block;
-    this->get_service().get_io_service().reset();
-    do this->get_service().get_io_service().run_one();
-    while (ec_ == boost::asio::error::would_block);
-
-    return !ec_ ? this : 0;
+    boost::system::error_code ec;
+    this->basic_socket<Protocol, StreamSocketService>::close(ec);
+    this->basic_socket<Protocol, StreamSocketService>::connect(endpoint, ec);
+    return !ec ? this : 0;
   }
 
 #if defined(GENERATING_DOCUMENTATION)
   /// Establish a connection.
   /**
    * This function automatically establishes a connection based on the supplied
    * resolver query parameters. The arguments are used to construct a resolver
    * query object.
    *
    * @return \c this if a connection was successfully established, a null
    * pointer otherwise.
    */
   template <typename T1, ..., typename TN>
   basic_socket_streambuf<Protocol, StreamSocketService>* connect(
       T1 t1, ..., TN tn);
-#elif defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES)
-  template <typename... T>
-  basic_socket_streambuf<Protocol, StreamSocketService,
-    Time, TimeTraits, TimerService>* connect(T... x)
-  {
-    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(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, _ )
 #endif
 
   /// Close the connection.
   /**
    * @return \c this if a connection was successfully established, a null
    * pointer otherwise.
    */
-  basic_socket_streambuf<Protocol, StreamSocketService,
-    Time, TimeTraits, TimerService>* close()
+  basic_socket_streambuf<Protocol, StreamSocketService>* close()
   {
+    boost::system::error_code ec;
     sync();
-    this->basic_socket<Protocol, StreamSocketService>::close(ec_);
-    if (!ec_)
+    this->basic_socket<Protocol, StreamSocketService>::close(ec);
+    if (!ec)
       init_buffers();
-    return !ec_ ? this : 0;
-  }
-
-  /// Get the last error associated with the stream buffer.
-  /**
-   * @return An \c error_code corresponding to the last error from the stream
-   * buffer.
-   */
-  const boost::system::error_code& puberror() const
-  {
-    return error();
-  }
-
-  /// Get the stream buffer's expiry time as an absolute time.
-  /**
-   * @return An absolute time value representing the stream buffer's expiry
-   * time.
-   */
-  time_type expires_at() const
-  {
-    return timer_service_
-      ? timer_service_->expires_at(timer_implementation_)
-      : time_type();
-  }
-
-  /// Set the stream buffer's expiry time as an absolute time.
-  /**
-   * This function sets the expiry time associated with the stream. Stream
-   * operations performed after this time (where the operations cannot be
-   * completed using the internal buffers) will fail with the error
-   * boost::asio::error::operation_aborted.
-   *
-   * @param expiry_time The expiry time to be used for the stream.
-   */
-  void expires_at(const time_type& expiry_time)
-  {
-    construct_timer();
-
-    boost::system::error_code ec;
-    timer_service_->expires_at(timer_implementation_, expiry_time, ec);
-    boost::asio::detail::throw_error(ec, "expires_at");
-
-    start_timer();
-  }
-
-  /// 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());
-  }
-
-  /// 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
-   * completed using the internal buffers) will fail with the error
-   * boost::asio::error::operation_aborted.
-   *
-   * @param expiry_time The expiry time to be used for the timer.
-   */
-  void expires_from_now(const duration_type& expiry_time)
-  {
-    construct_timer();
-
-    boost::system::error_code ec;
-    timer_service_->expires_from_now(timer_implementation_, expiry_time, ec);
-    boost::asio::detail::throw_error(ec, "expires_from_now");
-
-    start_timer();
+    return !ec ? this : 0;
   }
 
 protected:
   int_type underflow()
   {
     if (gptr() == egptr())
     {
-      if (timer_state_ == timer_has_expired)
-      {
-        ec_ = boost::asio::error::operation_aborted;
-        return traits_type::eof();
-      }
-
-      io_handler handler = { this };
-      this->get_service().async_receive(this->get_implementation(),
+      boost::system::error_code ec;
+      std::size_t bytes_transferred = this->service.receive(
+          this->implementation,
           boost::asio::buffer(boost::asio::buffer(get_buffer_) + putback_max),
-          0, handler);
-
-      ec_ = boost::asio::error::would_block;
-      this->get_service().get_io_service().reset();
-      do this->get_service().get_io_service().run_one();
-      while (ec_ == boost::asio::error::would_block);
-      if (ec_)
+          0, ec);
+      if (ec)
         return traits_type::eof();
-
-      setg(&get_buffer_[0], &get_buffer_[0] + putback_max,
-          &get_buffer_[0] + putback_max + bytes_transferred_);
+      setg(get_buffer_.begin(), get_buffer_.begin() + putback_max,
+          get_buffer_.begin() + putback_max + bytes_transferred);
       return traits_type::to_int_type(*gptr());
     }
     else
     {
       return traits_type::eof();
     }
   }
 
   int_type overflow(int_type c)
   {
     if (unbuffered_)
     {
       if (traits_type::eq_int_type(c, traits_type::eof()))
       {
         // Nothing to do.
         return traits_type::not_eof(c);
       }
       else
       {
-        if (timer_state_ == timer_has_expired)
-        {
-          ec_ = boost::asio::error::operation_aborted;
-          return traits_type::eof();
-        }
-
         // Send the single character immediately.
+        boost::system::error_code ec;
         char_type ch = traits_type::to_char_type(c);
-        io_handler handler = { this };
-        this->get_service().async_send(this->get_implementation(),
-            boost::asio::buffer(&ch, sizeof(char_type)), 0, handler);
-
-        ec_ = boost::asio::error::would_block;
-        this->get_service().get_io_service().reset();
-        do this->get_service().get_io_service().run_one();
-        while (ec_ == boost::asio::error::would_block);
-        if (ec_)
+        this->service.send(this->implementation,
+            boost::asio::buffer(&ch, sizeof(char_type)), 0, ec);
+        if (ec)
           return traits_type::eof();
-
         return c;
       }
     }
     else
     {
       // Send all data in the output buffer.
       boost::asio::const_buffer buffer =
         boost::asio::buffer(pbase(), pptr() - pbase());
       while (boost::asio::buffer_size(buffer) > 0)
       {
-        if (timer_state_ == timer_has_expired)
-        {
-          ec_ = boost::asio::error::operation_aborted;
-          return traits_type::eof();
-        }
-
-        io_handler handler = { this };
-        this->get_service().async_send(this->get_implementation(),
-            boost::asio::buffer(buffer), 0, handler);
-
-        ec_ = boost::asio::error::would_block;
-        this->get_service().get_io_service().reset();
-        do this->get_service().get_io_service().run_one();
-        while (ec_ == boost::asio::error::would_block);
-        if (ec_)
+        boost::system::error_code ec;
+        std::size_t bytes_transferred = this->service.send(
+            this->implementation, boost::asio::buffer(buffer),
+            0, ec);
+        if (ec)
           return traits_type::eof();
-
-        buffer = buffer + bytes_transferred_;
+        buffer = buffer + bytes_transferred;
       }
-      setp(&put_buffer_[0], &put_buffer_[0] + put_buffer_.size());
+      setp(put_buffer_.begin(), put_buffer_.end());
 
       // If the new character is eof then our work here is done.
       if (traits_type::eq_int_type(c, traits_type::eof()))
         return traits_type::not_eof(c);
 
       // Add the new character to the output buffer.
       *pptr() = traits_type::to_char_type(c);
       pbump(1);
       return c;
     }
   }
 
   int sync()
   {
     return overflow(traits_type::eof());
   }
 
   std::streambuf* setbuf(char_type* s, std::streamsize n)
   {
     if (pptr() == pbase() && s == 0 && n == 0)
     {
       unbuffered_ = true;
       setp(0, 0);
       return this;
     }
 
     return 0;
   }
 
-  /// Get the last error associated with the stream buffer.
-  /**
-   * @return An \c error_code corresponding to the last error from the stream
-   * buffer.
-   */
-  virtual const boost::system::error_code& error() const
-  {
-    return ec_;
-  }
-
 private:
   void init_buffers()
   {
-    setg(&get_buffer_[0],
-        &get_buffer_[0] + putback_max,
-        &get_buffer_[0] + putback_max);
+    setg(get_buffer_.begin(),
+        get_buffer_.begin() + putback_max,
+        get_buffer_.begin() + putback_max);
     if (unbuffered_)
       setp(0, 0);
     else
-      setp(&put_buffer_[0], &put_buffer_[0] + put_buffer_.size());
+      setp(put_buffer_.begin(), put_buffer_.end());
   }
 
   template <typename ResolverQuery>
-  void resolve_and_connect(const ResolverQuery& query)
+  void resolve_and_connect(const ResolverQuery& query,
+      boost::system::error_code& ec)
   {
     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);
-    iterator_type i = resolver.resolve(query, ec_);
-    if (!ec_)
+    iterator_type i = resolver.resolve(query, ec);
+    if (!ec)
     {
       iterator_type end;
-      ec_ = boost::asio::error::host_not_found;
-      while (ec_ && i != end)
+      ec = boost::asio::error::host_not_found;
+      while (ec && i != end)
       {
-        this->basic_socket<Protocol, StreamSocketService>::close(ec_);
-
-        if (timer_state_ == timer_has_expired)
-        {
-          ec_ = boost::asio::error::operation_aborted;
-          return;
-        }
-
-        io_handler handler = { this };
-        this->basic_socket<Protocol, StreamSocketService>::async_connect(
-            *i, handler);
-
-        ec_ = boost::asio::error::would_block;
-        this->get_service().get_io_service().reset();
-        do this->get_service().get_io_service().run_one();
-        while (ec_ == boost::asio::error::would_block);
-
+        this->basic_socket<Protocol, StreamSocketService>::close();
+        this->basic_socket<Protocol, StreamSocketService>::connect(*i, ec);
         ++i;
       }
     }
   }
 
-  struct io_handler;
-  friend struct io_handler;
-  struct io_handler
-  {
-    basic_socket_streambuf* this_;
-
-    void operator()(const boost::system::error_code& ec,
-        std::size_t bytes_transferred = 0)
-    {
-      this_->ec_ = ec;
-      this_->bytes_transferred_ = bytes_transferred;
-    }
-  };
-
-  struct timer_handler;
-  friend struct timer_handler;
-  struct timer_handler
-  {
-    basic_socket_streambuf* this_;
-
-    void operator()(const boost::system::error_code&)
-    {
-      time_type now = TimeTraits::now();
-
-      time_type expiry_time = this_->timer_service_->expires_at(
-            this_->timer_implementation_);
-
-      if (TimeTraits::less_than(now, expiry_time))
-      {
-        this_->timer_state_ = timer_is_pending;
-        this_->timer_service_->async_wait(this_->timer_implementation_, *this);
-      }
-      else
-      {
-        this_->timer_state_ = timer_has_expired;
-        boost::system::error_code ec;
-        this_->basic_socket<Protocol, StreamSocketService>::close(ec);
-      }
-    }
-  };
-
-  void construct_timer()
-  {
-    if (timer_service_ == 0)
-    {
-      TimerService& timer_service = use_service<TimerService>(
-          boost::base_from_member<boost::asio::io_service>::member);
-      timer_service.construct(timer_implementation_);
-      timer_service_ = &timer_service;
-    }
-  }
-
-  void destroy_timer()
-  {
-    if (timer_service_)
-      timer_service_->destroy(timer_implementation_);
-  }
-
-  void start_timer()
-  {
-    if (timer_state_ != timer_is_pending)
-    {
-      timer_handler handler = { this };
-      handler(boost::system::error_code());
-    }
-  }
-
   enum { putback_max = 8 };
   enum { buffer_size = 512 };
-  boost::asio::detail::array<char, buffer_size> get_buffer_;
-  boost::asio::detail::array<char, buffer_size> put_buffer_;
+  boost::array<char, buffer_size> get_buffer_;
+  boost::array<char, buffer_size> put_buffer_;
   bool unbuffered_;
-  boost::system::error_code ec_;
-  std::size_t bytes_transferred_;
-  TimerService* timer_service_;
-  typename TimerService::implementation_type timer_implementation_;
-  enum state { no_timer, timer_is_pending, timer_has_expired } timer_state_;
 };
 
 } // namespace asio
 } // namespace boost
 
 #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)
+#undef BOOST_ASIO_PRIVATE_CONNECT_DEF
 
 #endif // !defined(BOOST_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..87bd035 100644
--- a/3rdParty/Boost/src/boost/asio/basic_stream_socket.hpp
+++ b/3rdParty/Boost/src/boost/asio/basic_stream_socket.hpp
@@ -1,89 +1,84 @@
 //
 // basic_stream_socket.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_BASIC_STREAM_SOCKET_HPP
 #define BOOST_ASIO_BASIC_STREAM_SOCKET_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/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>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 
 /// Provides stream-oriented socket functionality.
 /**
  * The basic_stream_socket class template provides asynchronous and blocking
  * stream-oriented socket functionality.
  *
  * @par Thread Safety
  * @e Distinct @e objects: Safe.@n
  * @e Shared @e objects: Unsafe.
  *
  * @par Concepts:
  * AsyncReadStream, AsyncWriteStream, Stream, SyncReadStream, SyncWriteStream.
  */
 template <typename Protocol,
     typename StreamSocketService = stream_socket_service<Protocol> >
 class basic_stream_socket
   : public basic_socket<Protocol, StreamSocketService>
 {
 public:
-  /// (Deprecated: Use native_handle_type.) The native representation of a
-  /// socket.
-  typedef typename StreamSocketService::native_handle_type native_type;
-
   /// The native representation of a socket.
-  typedef typename StreamSocketService::native_handle_type native_handle_type;
+  typedef typename StreamSocketService::native_type native_type;
 
   /// The protocol type.
   typedef Protocol protocol_type;
 
   /// The endpoint type.
   typedef typename Protocol::endpoint endpoint_type;
 
   /// Construct a basic_stream_socket without opening it.
   /**
    * This constructor creates a stream socket without opening it. The socket
    * needs to be opened and then connected or accepted before data can be sent
    * or received on it.
    *
    * @param io_service The io_service object that the stream socket will use to
    * dispatch handlers for any asynchronous operations performed on the socket.
    */
   explicit basic_stream_socket(boost::asio::io_service& io_service)
     : basic_socket<Protocol, StreamSocketService>(io_service)
   {
   }
 
   /// Construct and open a basic_stream_socket.
   /**
    * This constructor creates and opens a stream socket. The socket needs to be
    * connected or accepted before data can be sent or received on it.
    *
    * @param io_service The io_service object that the stream socket will use to
    * dispatch handlers for any asynchronous operations performed on the socket.
    *
    * @param protocol An object specifying protocol parameters to be used.
    *
    * @throws boost::system::system_error Thrown on failure.
    */
   basic_stream_socket(boost::asio::io_service& io_service,
       const protocol_type& protocol)
@@ -95,703 +90,628 @@ public:
   /// local endpoint.
   /**
    * This constructor creates a stream socket and automatically opens it bound
    * to the specified endpoint on the local machine. The protocol used is the
    * protocol associated with the given endpoint.
    *
    * @param io_service The io_service object that the stream socket will use to
    * dispatch handlers for any asynchronous operations performed on the socket.
    *
    * @param endpoint An endpoint on the local machine to which the stream
    * socket will be bound.
    *
    * @throws boost::system::system_error Thrown on failure.
    */
   basic_stream_socket(boost::asio::io_service& io_service,
       const endpoint_type& endpoint)
     : basic_socket<Protocol, StreamSocketService>(io_service, endpoint)
   {
   }
 
   /// Construct a basic_stream_socket on an existing native socket.
   /**
    * This constructor creates a stream socket object to hold an existing native
    * socket.
    *
    * @param io_service The io_service object that the stream socket will use to
    * dispatch handlers for any asynchronous operations performed on the socket.
    *
    * @param protocol An object specifying protocol parameters to be used.
    *
    * @param native_socket The new underlying socket implementation.
    *
    * @throws boost::system::system_error Thrown on failure.
    */
   basic_stream_socket(boost::asio::io_service& io_service,
-      const protocol_type& protocol, const native_handle_type& native_socket)
+      const protocol_type& protocol, const native_type& native_socket)
     : basic_socket<Protocol, StreamSocketService>(
         io_service, protocol, native_socket)
   {
   }
 
-#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
-  /// Move-construct a basic_stream_socket from another.
-  /**
-   * 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.
-   */
-  basic_stream_socket(basic_stream_socket&& other)
-    : basic_socket<Protocol, StreamSocketService>(
-        BOOST_ASIO_MOVE_CAST(basic_stream_socket)(other))
-  {
-  }
-
-  /// Move-assign a basic_stream_socket from another.
-  /**
-   * 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.
-   */
-  basic_stream_socket& operator=(basic_stream_socket&& other)
-  {
-    basic_socket<Protocol, StreamSocketService>::operator=(
-        BOOST_ASIO_MOVE_CAST(basic_stream_socket)(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
    * successfully, or an until error occurs.
    *
    * @param buffers One or more data buffers to be sent on the socket.
    *
    * @returns The number of bytes sent.
    *
    * @throws boost::system::system_error Thrown on failure.
    *
    * @note The send operation may not transmit all of the data to the peer.
    * Consider using the @ref write function if you need to ensure that all data
    * is written before the blocking operation completes.
    *
    * @par Example
    * To send a single data buffer use the @ref buffer function as follows:
    * @code
    * socket.send(boost::asio::buffer(data, size));
    * @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>
   std::size_t send(const ConstBufferSequence& buffers)
   {
     boost::system::error_code ec;
-    std::size_t s = this->get_service().send(
-        this->get_implementation(), buffers, 0, ec);
-    boost::asio::detail::throw_error(ec, "send");
+    std::size_t s = this->service.send(
+        this->implementation, buffers, 0, ec);
+    boost::asio::detail::throw_error(ec);
     return s;
   }
 
   /// 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
    * successfully, or an until error occurs.
    *
    * @param buffers One or more data buffers to be sent on the socket.
    *
    * @param flags Flags specifying how the send call is to be made.
    *
    * @returns The number of bytes sent.
    *
    * @throws boost::system::system_error Thrown on failure.
    *
    * @note The send operation may not transmit all of the data to the peer.
    * Consider using the @ref write function if you need to ensure that all data
    * is written before the blocking operation completes.
    *
    * @par Example
    * To send a single data buffer use the @ref buffer function as follows:
    * @code
    * socket.send(boost::asio::buffer(data, size), 0);
    * @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>
   std::size_t send(const ConstBufferSequence& buffers,
       socket_base::message_flags flags)
   {
     boost::system::error_code ec;
-    std::size_t s = this->get_service().send(
-        this->get_implementation(), buffers, flags, ec);
-    boost::asio::detail::throw_error(ec, "send");
+    std::size_t s = this->service.send(
+        this->implementation, buffers, flags, ec);
+    boost::asio::detail::throw_error(ec);
     return s;
   }
 
   /// 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
    * successfully, or an until error occurs.
    *
    * @param buffers One or more data buffers to be sent on the socket.
    *
    * @param flags Flags specifying how the send call is to be made.
    *
    * @param ec Set to indicate what error occurred, if any.
    *
    * @returns The number of bytes sent. Returns 0 if an error occurred.
    *
    * @note The send operation may not transmit all of the data to the peer.
    * Consider using the @ref write function if you need to ensure that all data
    * is written before the blocking operation completes.
    */
   template <typename ConstBufferSequence>
   std::size_t send(const ConstBufferSequence& buffers,
       socket_base::message_flags flags, boost::system::error_code& ec)
   {
-    return this->get_service().send(
-        this->get_implementation(), buffers, flags, ec);
+    return this->service.send(this->implementation, buffers, flags, ec);
   }
 
   /// Start an asynchronous send.
   /**
    * This function is used to asynchronously send data on the stream 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.
    *
    * @param handler The handler to be called when the send operation completes.
    * Copies will be made of the handler as required. The function signature of
    * the handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
    *   std::size_t bytes_transferred           // Number of bytes sent.
    * ); @endcode
    * 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().
    *
    * @note The send operation may not transmit all of the data to the peer.
    * Consider using the @ref async_write function if you need to ensure that all
    * data is written before the asynchronous operation completes.
    *
    * @par Example
    * To send a single data buffer use the @ref buffer function as follows:
    * @code
    * socket.async_send(boost::asio::buffer(data, size), handler);
    * @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_MOVE_ARG(WriteHandler) handler)
+  void async_send(const ConstBufferSequence& buffers, 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,
-        BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
+    this->service.async_send(this->implementation, buffers, 0, handler);
   }
 
   /// Start an asynchronous send.
   /**
    * This function is used to asynchronously send data on the stream 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.
    *
    * @param flags Flags specifying how the send call is to be made.
    *
    * @param handler The handler to be called when the send operation completes.
    * Copies will be made of the handler as required. The function signature of
    * the handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
    *   std::size_t bytes_transferred           // Number of bytes sent.
    * ); @endcode
    * 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().
    *
    * @note The send operation may not transmit all of the data to the peer.
    * Consider using the @ref async_write function if you need to ensure that all
    * data is written before the asynchronous operation completes.
    *
    * @par Example
    * To send a single data buffer use the @ref buffer function as follows:
    * @code
    * socket.async_send(boost::asio::buffer(data, size), 0, handler);
    * @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,
-      socket_base::message_flags flags,
-      BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
+      socket_base::message_flags flags, 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,
-        BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
+    this->service.async_send(this->implementation, buffers, flags, handler);
   }
 
   /// Receive some data on the socket.
   /**
    * This function is used to receive data on the stream socket. The function
    * call will block until one or more bytes of data has been received
    * successfully, or until an error occurs.
    *
    * @param buffers One or more buffers into which the data will be received.
    *
    * @returns The number of bytes received.
    *
    * @throws boost::system::system_error Thrown on failure. An error code of
    * boost::asio::error::eof indicates that the connection was closed by the
    * peer.
    *
    * @note The receive operation may not receive all of the requested number of
    * bytes. Consider using the @ref read function if you need to ensure that the
    * requested amount of data is read before the blocking operation completes.
    *
    * @par Example
    * To receive into a single data buffer use the @ref buffer function as
    * follows:
    * @code
    * socket.receive(boost::asio::buffer(data, size));
    * @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>
   std::size_t receive(const MutableBufferSequence& buffers)
   {
     boost::system::error_code ec;
-    std::size_t s = this->get_service().receive(
-        this->get_implementation(), buffers, 0, ec);
-    boost::asio::detail::throw_error(ec, "receive");
+    std::size_t s = this->service.receive(this->implementation, buffers, 0, ec);
+    boost::asio::detail::throw_error(ec);
     return s;
   }
 
   /// Receive some data on the socket.
   /**
    * This function is used to receive data on the stream socket. The function
    * call will block until one or more bytes of data has been received
    * successfully, or until an error occurs.
    *
    * @param buffers One or more buffers into which the data will be received.
    *
    * @param flags Flags specifying how the receive call is to be made.
    *
    * @returns The number of bytes received.
    *
    * @throws boost::system::system_error Thrown on failure. An error code of
    * boost::asio::error::eof indicates that the connection was closed by the
    * peer.
    *
    * @note The receive operation may not receive all of the requested number of
    * bytes. Consider using the @ref read function if you need to ensure that the
    * requested amount of data is read before the blocking operation completes.
    *
    * @par Example
    * To receive into a single data buffer use the @ref buffer function as
    * follows:
    * @code
    * socket.receive(boost::asio::buffer(data, size), 0);
    * @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>
   std::size_t receive(const MutableBufferSequence& buffers,
       socket_base::message_flags flags)
   {
     boost::system::error_code ec;
-    std::size_t s = this->get_service().receive(
-        this->get_implementation(), buffers, flags, ec);
-    boost::asio::detail::throw_error(ec, "receive");
+    std::size_t s = this->service.receive(
+        this->implementation, buffers, flags, ec);
+    boost::asio::detail::throw_error(ec);
     return s;
   }
 
   /// Receive some data on a connected socket.
   /**
    * This function is used to receive data on the stream socket. The function
    * call will block until one or more bytes of data has been received
    * successfully, or until an error occurs.
    *
    * @param buffers One or more buffers into which the data will be received.
    *
    * @param flags Flags specifying how the receive call is to be made.
    *
    * @param ec Set to indicate what error occurred, if any.
    *
    * @returns The number of bytes received. Returns 0 if an error occurred.
    *
    * @note The receive operation may not receive all of the requested number of
    * bytes. Consider using the @ref read 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 receive(const MutableBufferSequence& buffers,
       socket_base::message_flags flags, boost::system::error_code& ec)
   {
-    return this->get_service().receive(
-        this->get_implementation(), buffers, flags, ec);
+    return this->service.receive(this->implementation, buffers, flags, ec);
   }
 
   /// Start an asynchronous receive.
   /**
    * This function is used to asynchronously receive data from the stream
    * socket. The function call always returns immediately.
    *
    * @param buffers One or more buffers into which the data will be received.
    * 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.
    *
    * @param handler The handler to be called when the receive operation
    * completes. Copies will be made of the handler as required. The function
    * signature of the handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
    *   std::size_t bytes_transferred           // Number of bytes received.
    * ); @endcode
    * 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().
    *
    * @note The receive operation may not receive all of the requested number of
    * bytes. Consider using the @ref async_read function if you need to ensure
    * that the requested amount of data is received before the asynchronous
    * operation completes.
    *
    * @par Example
    * To receive into a single data buffer use the @ref buffer function as
    * follows:
    * @code
    * socket.async_receive(boost::asio::buffer(data, size), 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(const MutableBufferSequence& buffers,
-      BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+  void async_receive(const MutableBufferSequence& buffers, 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, BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
+    this->service.async_receive(this->implementation, buffers, 0, handler);
   }
 
   /// Start an asynchronous receive.
   /**
    * This function is used to asynchronously receive data from the stream
    * socket. The function call always returns immediately.
    *
    * @param buffers One or more buffers into which the data will be received.
    * 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.
    *
    * @param flags Flags specifying how the receive call is to be made.
    *
    * @param handler The handler to be called when the receive operation
    * completes. Copies will be made of the handler as required. The function
    * signature of the handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
    *   std::size_t bytes_transferred           // Number of bytes received.
    * ); @endcode
    * 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().
    *
    * @note The receive operation may not receive all of the requested number of
    * bytes. Consider using the @ref async_read function if you need to ensure
    * that the requested amount of data is received before the asynchronous
    * operation completes.
    *
    * @par Example
    * To receive into a single data buffer use the @ref buffer function as
    * follows:
    * @code
    * socket.async_receive(boost::asio::buffer(data, size), 0, 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(const MutableBufferSequence& buffers,
-      socket_base::message_flags flags,
-      BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+      socket_base::message_flags flags, 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, flags, BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
+    this->service.async_receive(this->implementation, buffers, flags, handler);
   }
 
   /// Write some data to the socket.
   /**
    * This function is used to write data to the stream socket. The function call
    * will block until one or more bytes of the data has been written
    * successfully, or until an error occurs.
    *
    * @param buffers One or more data buffers to be written to the socket.
    *
    * @returns The number of bytes written.
    *
    * @throws boost::system::system_error Thrown on failure. An error code of
    * boost::asio::error::eof indicates that the connection was closed by the
    * peer.
    *
    * @note The write_some operation may not transmit all of the data to the
    * peer. Consider using the @ref write function if you need to ensure that
    * all data is written before the blocking operation completes.
    *
    * @par Example
    * To write a single data buffer use the @ref buffer function as follows:
    * @code
    * socket.write_some(boost::asio::buffer(data, size));
    * @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(const ConstBufferSequence& buffers)
   {
     boost::system::error_code ec;
-    std::size_t s = this->get_service().send(
-        this->get_implementation(), buffers, 0, ec);
-    boost::asio::detail::throw_error(ec, "write_some");
+    std::size_t s = this->service.send(this->implementation, buffers, 0, ec);
+    boost::asio::detail::throw_error(ec);
     return s;
   }
 
   /// Write some data to the socket.
   /**
    * This function is used to write data to the stream socket. The function call
    * will block until one or more bytes of the data has been written
    * successfully, or until an error occurs.
    *
    * @param buffers One or more data buffers to be written to the socket.
    *
    * @param ec Set to indicate what error occurred, if any.
    *
    * @returns The number of bytes written. Returns 0 if an error occurred.
    *
    * @note The write_some operation may not transmit all of the data to the
    * peer. Consider using the @ref write function if you need to ensure that
    * all data is written before the blocking operation completes.
    */
   template <typename ConstBufferSequence>
   std::size_t write_some(const ConstBufferSequence& buffers,
       boost::system::error_code& ec)
   {
-    return this->get_service().send(this->get_implementation(), buffers, 0, ec);
+    return this->service.send(this->implementation, buffers, 0, ec);
   }
 
   /// Start an asynchronous write.
   /**
    * This function is used to asynchronously write data to the stream socket.
    * The function call always returns immediately.
    *
    * @param buffers One or more data buffers to be written to 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.
    *
    * @param handler The handler to be called when the write operation completes.
    * Copies will be made of the handler as required. The function signature of
    * the handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
    *   std::size_t bytes_transferred           // Number of bytes written.
    * ); @endcode
    * 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().
    *
    * @note The write operation may not transmit all of the data to the peer.
    * Consider using the @ref async_write function if you need to ensure that all
    * data is written before the asynchronous operation completes.
    *
    * @par Example
    * To write a single data buffer use the @ref buffer function as follows:
    * @code
    * socket.async_write_some(boost::asio::buffer(data, size), handler);
    * @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_MOVE_ARG(WriteHandler) handler)
+      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, BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
+    this->service.async_send(this->implementation, buffers, 0, handler);
   }
 
   /// Read some data from the socket.
   /**
    * This function is used to read data from the stream socket. The function
    * call will block until one or more bytes of data has been read successfully,
    * or until an error occurs.
    *
    * @param buffers One or more buffers into which the data will be read.
    *
    * @returns The number of bytes read.
    *
    * @throws boost::system::system_error Thrown on failure. An error code of
    * boost::asio::error::eof indicates that the connection was closed by the
    * peer.
    *
    * @note The read_some operation may not read all of the requested number of
    * bytes. Consider using the @ref read function if you need to ensure that
    * the requested amount of data is read before the blocking operation
    * completes.
    *
    * @par Example
    * To read into a single data buffer use the @ref buffer function as follows:
    * @code
    * socket.read_some(boost::asio::buffer(data, size));
    * @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(const MutableBufferSequence& buffers)
   {
     boost::system::error_code ec;
-    std::size_t s = this->get_service().receive(
-        this->get_implementation(), buffers, 0, ec);
-    boost::asio::detail::throw_error(ec, "read_some");
+    std::size_t s = this->service.receive(this->implementation, buffers, 0, ec);
+    boost::asio::detail::throw_error(ec);
     return s;
   }
 
   /// Read some data from the socket.
   /**
    * This function is used to read data from the stream socket. The function
    * call will block until one or more bytes of data has been read successfully,
    * or until an error occurs.
    *
    * @param buffers One or more buffers into which the data will be read.
    *
    * @param ec Set to indicate what error occurred, if any.
    *
    * @returns The number of bytes read. Returns 0 if an error occurred.
    *
    * @note The read_some operation may not read all of the requested number of
    * bytes. Consider using the @ref read 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(const MutableBufferSequence& buffers,
       boost::system::error_code& ec)
   {
-    return this->get_service().receive(
-        this->get_implementation(), buffers, 0, ec);
+    return this->service.receive(this->implementation, buffers, 0, ec);
   }
 
   /// Start an asynchronous read.
   /**
    * This function is used to asynchronously read data from the stream socket.
    * The function call always returns immediately.
    *
    * @param buffers One or more buffers into which the data will be read.
    * 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.
    *
    * @param handler The handler to be called when the read operation completes.
    * Copies will be made of the handler as required. The function signature of
    * the handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
    *   std::size_t bytes_transferred           // Number of bytes read.
    * ); @endcode
    * 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().
    *
    * @note The read operation may not read all of the requested number of bytes.
    * Consider using the @ref async_read function if you need to ensure that the
    * requested amount of data is read before the asynchronous operation
    * completes.
    *
    * @par Example
    * To read into a single data buffer use the @ref buffer function as follows:
    * @code
    * socket.async_read_some(boost::asio::buffer(data, size), handler);
    * @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_MOVE_ARG(ReadHandler) handler)
+      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, BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
+    this->service.async_receive(this->implementation, buffers, 0, handler);
   }
 };
 
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // BOOST_ASIO_BASIC_STREAM_SOCKET_HPP
diff --git a/3rdParty/Boost/src/boost/asio/basic_streambuf.hpp b/3rdParty/Boost/src/boost/asio/basic_streambuf.hpp
index e77624b..7a04c69 100644
--- a/3rdParty/Boost/src/boost/asio/basic_streambuf.hpp
+++ b/3rdParty/Boost/src/boost/asio/basic_streambuf.hpp
@@ -1,40 +1,40 @@
 //
 // basic_streambuf.hpp
 // ~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_BASIC_STREAMBUF_HPP
 #define BOOST_ASIO_BASIC_STREAMBUF_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_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/noncopyable.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 
 /// Automatically resizable buffer class based on std::streambuf.
 /**
  * The @c basic_streambuf class is derived from @c std::streambuf to associate
@@ -98,73 +98,73 @@ namespace asio {
  * // received data is "committed" from output sequence to input sequence
  * b.commit(n);
  *
  * std::istream is(&b);
  * std::string s;
  * is >> s;
  * @endcode
  */
 #if defined(GENERATING_DOCUMENTATION)
 template <typename Allocator = std::allocator<char> >
 #else
 template <typename Allocator>
 #endif
 class basic_streambuf
   : public std::streambuf,
     private noncopyable
 {
 public:
 #if defined(GENERATING_DOCUMENTATION)
   /// The type used to represent the input sequence as a list of buffers.
   typedef implementation_defined const_buffers_type;
 
   /// The type used to represent the output sequence as a list of buffers.
   typedef implementation_defined mutable_buffers_type;
 #else
   typedef boost::asio::const_buffers_1 const_buffers_type;
   typedef boost::asio::mutable_buffers_1 mutable_buffers_type;
 #endif
 
   /// Construct a basic_streambuf object.
   /**
    * Constructs a streambuf with the specified maximum size. The initial size
    * of the streambuf's input sequence is 0.
    */
   explicit basic_streambuf(
-      std::size_t maximum_size = (std::numeric_limits<std::size_t>::max)(),
+      std::size_t max_size = (std::numeric_limits<std::size_t>::max)(),
       const Allocator& allocator = Allocator())
-    : max_size_(maximum_size),
+    : max_size_(max_size),
       buffer_(allocator)
   {
     std::size_t pend = (std::min<std::size_t>)(max_size_, buffer_delta);
     buffer_.resize((std::max<std::size_t>)(pend, 1));
     setg(&buffer_[0], &buffer_[0], &buffer_[0]);
     setp(&buffer_[0], &buffer_[0] + pend);
   }
 
   /// Get the size of the input sequence.
   /**
    * @returns The size of the input sequence. The value is equal to that
    * calculated for @c s in the following code:
    * @code
    * size_t s = 0;
    * const_buffers_type bufs = data();
    * const_buffers_type::const_iterator i = bufs.begin();
    * while (i != bufs.end())
    * {
    *   const_buffer buf(*i++);
    *   s += buffer_size(buf);
    * }
    * @endcode
    */
   std::size_t size() const
   {
     return pptr() - gptr();
   }
 
   /// Get the maximum size of the basic_streambuf.
   /**
    * @returns The allowed maximum of the sum of the sizes of the input sequence
    * and output sequence.
    */
   std::size_t max_size() const
   {
diff --git a/3rdParty/Boost/src/boost/asio/basic_streambuf_fwd.hpp b/3rdParty/Boost/src/boost/asio/basic_streambuf_fwd.hpp
index ca806ea..a7d82d3 100644
--- a/3rdParty/Boost/src/boost/asio/basic_streambuf_fwd.hpp
+++ b/3rdParty/Boost/src/boost/asio/basic_streambuf_fwd.hpp
@@ -1,35 +1,35 @@
 //
 // basic_streambuf_fwd.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_BASIC_STREAMBUF_FWD_HPP
 #define BOOST_ASIO_BASIC_STREAMBUF_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_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 // 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
deleted file mode 100644
index d957bde..0000000
--- a/3rdParty/Boost/src/boost/asio/basic_waitable_timer.hpp
+++ /dev/null
@@ -1,518 +0,0 @@
-//
-// basic_waitable_timer.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_BASIC_WAITABLE_TIMER_HPP
-#define BOOST_ASIO_BASIC_WAITABLE_TIMER_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/basic_io_object.hpp>
-#include <boost/asio/detail/handler_type_requirements.hpp>
-#include <boost/asio/detail/throw_error.hpp>
-#include <boost/asio/error.hpp>
-#include <boost/asio/wait_traits.hpp>
-#include <boost/asio/waitable_timer_service.hpp>
-
-#include <boost/asio/detail/push_options.hpp>
-
-namespace boost {
-namespace asio {
-
-/// Provides waitable timer functionality.
-/**
- * The basic_waitable_timer class template provides the ability to perform a
- * 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.
- *
- * @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:
- * @code
- * // Construct a timer without setting an expiry time.
- * boost::asio::waitable_timer timer(io_service);
- *
- * // Set an expiry time relative to now.
- * timer.expires_from_now(boost::posix_time::seconds(5));
- *
- * // Wait for the timer to expire.
- * timer.wait();
- * @endcode
- *
- * @par 
- * Performing an asynchronous wait:
- * @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"));
- *
- * // Start an asynchronous wait.
- * timer.async_wait(handler);
- * @endcode
- *
- * @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:
- *
- * @code
- * void on_some_event()
- * {
- *   if (my_timer.expires_from_now(seconds(5)) > 0)
- *   {
- *     // We managed to cancel the timer. Start new asynchronous wait.
- *     my_timer.async_wait(on_timeout);
- *   }
- *   else
- *   {
- *     // Too late, timer has already expired!
- *   }
- * }
- *
- * void on_timeout(const boost::system::error_code& e)
- * {
- *   if (e != boost::asio::error::operation_aborted)
- *   {
- *     // Timer was not cancelled, take necessary action.
- *   }
- * }
- * @endcode
- *
- * @li The boost::asio::basic_waitable_timer::expires_from_now() function
- * cancels any pending asynchronous waits, and returns the number of
- * asynchronous waits that were cancelled. If it returns 0 then you were too
- * late and the wait handler has already been executed, or will soon be
- * executed. If it returns 1 then the wait handler was successfully cancelled.
- *
- * @li If a wait handler is cancelled, the boost::system::error_code passed to
- * it contains the value boost::asio::error::operation_aborted.
- */
-template <typename Clock,
-    typename WaitTraits = boost::asio::wait_traits<Clock>,
-    typename WaitableTimerService = waitable_timer_service<Clock, WaitTraits> >
-class basic_waitable_timer
-  : public basic_io_object<WaitableTimerService>
-{
-public:
-  /// The clock type.
-  typedef Clock clock_type;
-
-  /// The duration type of the clock.
-  typedef typename clock_type::duration duration;
-
-  /// The time point type of the clock.
-  typedef typename clock_type::time_point time_point;
-
-  /// The wait traits type.
-  typedef WaitTraits traits_type;
-
-  /// Constructor.
-  /**
-   * This constructor creates a timer without setting an expiry time. The
-   * expires_at() or expires_from_now() functions must be called to set an
-   * expiry time before the timer can be waited on.
-   *
-   * @param io_service The io_service object that the timer will use to dispatch
-   * handlers for any asynchronous operations performed on the timer.
-   */
-  explicit basic_waitable_timer(boost::asio::io_service& io_service)
-    : basic_io_object<WaitableTimerService>(io_service)
-  {
-  }
-
-  /// Constructor to set a particular expiry time as an absolute time.
-  /**
-   * This constructor creates a timer and sets the expiry time.
-   *
-   * @param io_service The io_service object that the timer will use to dispatch
-   * handlers for any asynchronous operations performed on the timer.
-   *
-   * @param expiry_time The expiry time to be used for the timer, expressed
-   * as an absolute time.
-   */
-  basic_waitable_timer(boost::asio::io_service& io_service,
-      const time_point& expiry_time)
-    : basic_io_object<WaitableTimerService>(io_service)
-  {
-    boost::system::error_code ec;
-    this->service.expires_at(this->implementation, expiry_time, ec);
-    boost::asio::detail::throw_error(ec, "expires_at");
-  }
-
-  /// Constructor to set a particular expiry time relative to now.
-  /**
-   * This constructor creates a timer and sets the expiry time.
-   *
-   * @param io_service The io_service object that the timer will use to dispatch
-   * handlers for any asynchronous operations performed on the timer.
-   *
-   * @param expiry_time The expiry time to be used for the timer, relative to
-   * now.
-   */
-  basic_waitable_timer(boost::asio::io_service& io_service,
-      const duration& expiry_time)
-    : basic_io_object<WaitableTimerService>(io_service)
-  {
-    boost::system::error_code ec;
-    this->service.expires_from_now(this->implementation, expiry_time, ec);
-    boost::asio::detail::throw_error(ec, "expires_from_now");
-  }
-
-  /// Cancel any asynchronous operations that are waiting on the timer.
-  /**
-   * This function forces the completion of any pending asynchronous wait
-   * operations against the timer. The handler for each cancelled operation will
-   * be invoked with the boost::asio::error::operation_aborted error code.
-   *
-   * Cancelling the timer does not change the expiry time.
-   *
-   * @return The number of asynchronous operations that were cancelled.
-   *
-   * @throws boost::system::system_error Thrown on failure.
-   *
-   * @note If the timer has already expired when cancel() is called, then the
-   * handlers for asynchronous wait operations will:
-   *
-   * @li have already been invoked; or
-   *
-   * @li have been queued for invocation in the near future.
-   *
-   * These handlers can no longer be cancelled, and therefore are passed an
-   * error code that indicates the successful completion of the wait operation.
-   */
-  std::size_t cancel()
-  {
-    boost::system::error_code ec;
-    std::size_t s = this->service.cancel(this->implementation, ec);
-    boost::asio::detail::throw_error(ec, "cancel");
-    return s;
-  }
-
-  /// Cancel any asynchronous operations that are waiting on the timer.
-  /**
-   * This function forces the completion of any pending asynchronous wait
-   * operations against the timer. The handler for each cancelled operation will
-   * be invoked with the boost::asio::error::operation_aborted error code.
-   *
-   * Cancelling the timer does not change the expiry time.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @return The number of asynchronous operations that were cancelled.
-   *
-   * @note If the timer has already expired when cancel() is called, then the
-   * handlers for asynchronous wait operations will:
-   *
-   * @li have already been invoked; or
-   *
-   * @li have been queued for invocation in the near future.
-   *
-   * These handlers can no longer be cancelled, and therefore are passed an
-   * error code that indicates the successful completion of the wait operation.
-   */
-  std::size_t cancel(boost::system::error_code& ec)
-  {
-    return this->service.cancel(this->implementation, ec);
-  }
-
-  /// Cancels one asynchronous operation that is waiting on the timer.
-  /**
-   * This function forces the completion of one pending asynchronous wait
-   * operation against the timer. Handlers are cancelled in FIFO order. The
-   * handler for the cancelled operation will be invoked with the
-   * boost::asio::error::operation_aborted error code.
-   *
-   * Cancelling the timer does not change the expiry time.
-   *
-   * @return The number of asynchronous operations that were cancelled. That is,
-   * either 0 or 1.
-   *
-   * @throws boost::system::system_error Thrown on failure.
-   *
-   * @note If the timer has already expired when cancel_one() is called, then
-   * the handlers for asynchronous wait operations will:
-   *
-   * @li have already been invoked; or
-   *
-   * @li have been queued for invocation in the near future.
-   *
-   * These handlers can no longer be cancelled, and therefore are passed an
-   * error code that indicates the successful completion of the wait operation.
-   */
-  std::size_t cancel_one()
-  {
-    boost::system::error_code ec;
-    std::size_t s = this->service.cancel_one(this->implementation, ec);
-    boost::asio::detail::throw_error(ec, "cancel_one");
-    return s;
-  }
-
-  /// Cancels one asynchronous operation that is waiting on the timer.
-  /**
-   * This function forces the completion of one pending asynchronous wait
-   * operation against the timer. Handlers are cancelled in FIFO order. The
-   * handler for the cancelled operation will be invoked with the
-   * boost::asio::error::operation_aborted error code.
-   *
-   * Cancelling the timer does not change the expiry time.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @return The number of asynchronous operations that were cancelled. That is,
-   * either 0 or 1.
-   *
-   * @note If the timer has already expired when cancel_one() is called, then
-   * the handlers for asynchronous wait operations will:
-   *
-   * @li have already been invoked; or
-   *
-   * @li have been queued for invocation in the near future.
-   *
-   * These handlers can no longer be cancelled, and therefore are passed an
-   * error code that indicates the successful completion of the wait operation.
-   */
-  std::size_t cancel_one(boost::system::error_code& ec)
-  {
-    return this->service.cancel_one(this->implementation, ec);
-  }
-
-  /// Get the timer's expiry time as an absolute time.
-  /**
-   * This function may be used to obtain the timer's current expiry time.
-   * Whether the timer has expired or not does not affect this value.
-   */
-  time_point expires_at() const
-  {
-    return this->service.expires_at(this->implementation);
-  }
-
-  /// Set the timer's expiry time as an absolute time.
-  /**
-   * This function sets the expiry time. Any pending asynchronous wait
-   * operations will be cancelled. The handler for each cancelled operation will
-   * be invoked with the boost::asio::error::operation_aborted error code.
-   *
-   * @param expiry_time The expiry time to be used for the timer.
-   *
-   * @return The number of asynchronous operations that were cancelled.
-   *
-   * @throws boost::system::system_error Thrown on failure.
-   *
-   * @note If the timer has already expired when expires_at() is called, then
-   * the handlers for asynchronous wait operations will:
-   *
-   * @li have already been invoked; or
-   *
-   * @li have been queued for invocation in the near future.
-   *
-   * These handlers can no longer be cancelled, and therefore are passed an
-   * error code that indicates the successful completion of the wait operation.
-   */
-  std::size_t expires_at(const time_point& expiry_time)
-  {
-    boost::system::error_code ec;
-    std::size_t s = this->service.expires_at(
-        this->implementation, expiry_time, ec);
-    boost::asio::detail::throw_error(ec, "expires_at");
-    return s;
-  }
-
-  /// Set the timer's expiry time as an absolute time.
-  /**
-   * This function sets the expiry time. Any pending asynchronous wait
-   * operations will be cancelled. The handler for each cancelled operation will
-   * be invoked with the boost::asio::error::operation_aborted error code.
-   *
-   * @param expiry_time The expiry time to be used for the timer.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @return The number of asynchronous operations that were cancelled.
-   *
-   * @note If the timer has already expired when expires_at() is called, then
-   * the handlers for asynchronous wait operations will:
-   *
-   * @li have already been invoked; or
-   *
-   * @li have been queued for invocation in the near future.
-   *
-   * These handlers can no longer be cancelled, and therefore are passed an
-   * error code that indicates the successful completion of the wait operation.
-   */
-  std::size_t expires_at(const time_point& expiry_time,
-      boost::system::error_code& ec)
-  {
-    return this->service.expires_at(this->implementation, expiry_time, ec);
-  }
-
-  /// Get the timer's expiry time relative to now.
-  /**
-   * This function may be used to obtain the timer's current expiry time.
-   * Whether the timer has expired or not does not affect this value.
-   */
-  duration expires_from_now() const
-  {
-    return this->service.expires_from_now(this->implementation);
-  }
-
-  /// Set the timer's expiry time relative to now.
-  /**
-   * This function sets the expiry time. Any pending asynchronous wait
-   * operations will be cancelled. The handler for each cancelled operation will
-   * be invoked with the boost::asio::error::operation_aborted error code.
-   *
-   * @param expiry_time The expiry time to be used for the timer.
-   *
-   * @return The number of asynchronous operations that were cancelled.
-   *
-   * @throws boost::system::system_error Thrown on failure.
-   *
-   * @note If the timer has already expired when expires_from_now() is called,
-   * then the handlers for asynchronous wait operations will:
-   *
-   * @li have already been invoked; or
-   *
-   * @li have been queued for invocation in the near future.
-   *
-   * These handlers can no longer be cancelled, and therefore are passed an
-   * error code that indicates the successful completion of the wait operation.
-   */
-  std::size_t expires_from_now(const duration& expiry_time)
-  {
-    boost::system::error_code ec;
-    std::size_t s = this->service.expires_from_now(
-        this->implementation, expiry_time, ec);
-    boost::asio::detail::throw_error(ec, "expires_from_now");
-    return s;
-  }
-
-  /// Set the timer's expiry time relative to now.
-  /**
-   * This function sets the expiry time. Any pending asynchronous wait
-   * operations will be cancelled. The handler for each cancelled operation will
-   * be invoked with the boost::asio::error::operation_aborted error code.
-   *
-   * @param expiry_time The expiry time to be used for the timer.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @return The number of asynchronous operations that were cancelled.
-   *
-   * @note If the timer has already expired when expires_from_now() is called,
-   * then the handlers for asynchronous wait operations will:
-   *
-   * @li have already been invoked; or
-   *
-   * @li have been queued for invocation in the near future.
-   *
-   * These handlers can no longer be cancelled, and therefore are passed an
-   * error code that indicates the successful completion of the wait operation.
-   */
-  std::size_t expires_from_now(const duration& expiry_time,
-      boost::system::error_code& ec)
-  {
-    return this->service.expires_from_now(
-        this->implementation, expiry_time, ec);
-  }
-
-  /// Perform a blocking wait on the timer.
-  /**
-   * This function is used to wait for the timer to expire. This function
-   * blocks and does not return until the timer has expired.
-   *
-   * @throws boost::system::system_error Thrown on failure.
-   */
-  void wait()
-  {
-    boost::system::error_code ec;
-    this->service.wait(this->implementation, ec);
-    boost::asio::detail::throw_error(ec, "wait");
-  }
-
-  /// Perform a blocking wait on the timer.
-  /**
-   * This function is used to wait for the timer to expire. This function
-   * blocks and does not return until the timer has expired.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   */
-  void wait(boost::system::error_code& ec)
-  {
-    this->service.wait(this->implementation, ec);
-  }
-
-  /// Start an asynchronous wait on the timer.
-  /**
-   * This function may be used to initiate an asynchronous wait against the
-   * timer. It always returns immediately.
-   *
-   * For each call to async_wait(), the supplied handler will be called exactly
-   * once. The handler will be called when:
-   *
-   * @li The timer has expired.
-   *
-   * @li The timer was cancelled, in which case the handler is passed the error
-   * code boost::asio::error::operation_aborted.
-   *
-   * @param handler The handler to be called when the timer expires. Copies
-   * will be made of the handler as required. The function signature of the
-   * handler must be:
-   * @code void handler(
-   *   const boost::system::error_code& error // Result of operation.
-   * ); @endcode
-   * 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)
-  {
-    // 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,
-        BOOST_ASIO_MOVE_CAST(WaitHandler)(handler));
-  }
-};
-
-} // namespace asio
-} // namespace boost
-
-#include <boost/asio/detail/pop_options.hpp>
-
-#endif // BOOST_ASIO_BASIC_WAITABLE_TIMER_HPP
diff --git a/3rdParty/Boost/src/boost/asio/buffer.hpp b/3rdParty/Boost/src/boost/asio/buffer.hpp
index 532cfd1..15eaad4 100644
--- a/3rdParty/Boost/src/boost/asio/buffer.hpp
+++ b/3rdParty/Boost/src/boost/asio/buffer.hpp
@@ -1,239 +1,265 @@
 //
 // buffer.hpp
 // ~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_BUFFER_HPP
 #define BOOST_ASIO_BUFFER_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 <cstring>
 #include <string>
 #include <vector>
 #include <boost/detail/workaround.hpp>
 #include <boost/asio/detail/array_fwd.hpp>
 
 #if defined(BOOST_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)
 
 #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>
 #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))
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 
 class mutable_buffer;
 class const_buffer;
 
 namespace detail {
 void* buffer_cast_helper(const mutable_buffer&);
 const void* buffer_cast_helper(const const_buffer&);
 std::size_t buffer_size_helper(const mutable_buffer&);
 std::size_t buffer_size_helper(const const_buffer&);
 } // namespace detail
 
 /// Holds a buffer that can be modified.
 /**
  * The mutable_buffer class provides a safe representation of a buffer that can
  * be modified. It does not own the underlying data, and so is cheap to copy or
  * assign.
- *
- * @par Accessing Buffer Contents
- *
- * The contents of a buffer may be accessed using the @ref buffer_size
- * and @ref buffer_cast functions:
- *
- * @code boost::asio::mutable_buffer b1 = ...;
- * std::size_t s1 = boost::asio::buffer_size(b1);
- * unsigned char* p1 = boost::asio::buffer_cast<unsigned char*>(b1);
- * @endcode
- *
- * The boost::asio::buffer_cast function permits violations of type safety, so
- * uses of it in application code should be carefully considered.
  */
 class mutable_buffer
 {
 public:
   /// Construct an empty buffer.
   mutable_buffer()
     : data_(0),
       size_(0)
   {
   }
 
   /// Construct a buffer to represent a given memory range.
   mutable_buffer(void* data, std::size_t size)
     : data_(data),
       size_(size)
   {
   }
 
 #if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)
   mutable_buffer(void* data, std::size_t size,
       boost::function<void()> debug_check)
     : data_(data),
       size_(size),
       debug_check_(debug_check)
   {
   }
 
   const boost::function<void()>& get_debug_check() const
   {
     return debug_check_;
   }
 #endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING
 
 private:
   friend void* boost::asio::detail::buffer_cast_helper(
       const mutable_buffer& b);
   friend std::size_t boost::asio::detail::buffer_size_helper(
       const mutable_buffer& b);
 
   void* data_;
   std::size_t size_;
 
 #if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)
   boost::function<void()> debug_check_;
 #endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING
 };
 
 namespace detail {
 
 inline void* buffer_cast_helper(const mutable_buffer& b)
 {
 #if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)
   if (b.size_ && b.debug_check_)
     b.debug_check_();
 #endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING
   return b.data_;
 }
 
 inline std::size_t buffer_size_helper(const mutable_buffer& b)
 {
   return b.size_;
 }
 
 } // namespace detail
 
+/// Cast a non-modifiable buffer to a specified pointer to POD type.
+/**
+ * @relates mutable_buffer
+ */
+template <typename PointerToPodType>
+inline PointerToPodType buffer_cast(const mutable_buffer& b)
+{
+  return static_cast<PointerToPodType>(detail::buffer_cast_helper(b));
+}
+
+/// Get the number of bytes in a non-modifiable buffer.
+/**
+ * @relates mutable_buffer
+ */
+inline std::size_t buffer_size(const mutable_buffer& b)
+{
+  return detail::buffer_size_helper(b);
+}
+
+/// Create a new modifiable buffer that is offset from the start of another.
+/**
+ * @relates mutable_buffer
+ */
+inline mutable_buffer operator+(const mutable_buffer& b, std::size_t start)
+{
+  if (start > buffer_size(b))
+    return mutable_buffer();
+  char* new_data = buffer_cast<char*>(b) + start;
+  std::size_t new_size = buffer_size(b) - start;
+  return mutable_buffer(new_data, new_size
+#if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)
+      , b.get_debug_check()
+#endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING
+      );
+}
+
+/// Create a new modifiable buffer that is offset from the start of another.
+/**
+ * @relates mutable_buffer
+ */
+inline mutable_buffer operator+(std::size_t start, const mutable_buffer& b)
+{
+  if (start > buffer_size(b))
+    return mutable_buffer();
+  char* new_data = buffer_cast<char*>(b) + start;
+  std::size_t new_size = buffer_size(b) - start;
+  return mutable_buffer(new_data, new_size
+#if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)
+      , b.get_debug_check()
+#endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING
+      );
+}
+
 /// Adapts a single modifiable buffer so that it meets the requirements of the
 /// MutableBufferSequence concept.
 class mutable_buffers_1
   : public mutable_buffer
 {
 public:
   /// The type for each element in the list of buffers.
   typedef mutable_buffer value_type;
 
   /// A random-access iterator type that may be used to read elements.
   typedef const mutable_buffer* const_iterator;
 
   /// Construct to represent a given memory range.
   mutable_buffers_1(void* data, std::size_t size)
     : mutable_buffer(data, size)
   {
   }
 
   /// Construct to represent a single modifiable buffer.
   explicit mutable_buffers_1(const mutable_buffer& b)
     : mutable_buffer(b)
   {
   }
 
   /// Get a random-access iterator to the first element.
   const_iterator begin() const
   {
     return this;
   }
 
   /// Get a random-access iterator for one past the last element.
   const_iterator end() const
   {
     return begin() + 1;
   }
 };
 
 /// Holds a buffer that cannot be modified.
 /**
  * The const_buffer class provides a safe representation of a buffer that cannot
  * be modified. It does not own the underlying data, and so is cheap to copy or
  * assign.
- *
- * @par Accessing Buffer Contents
- *
- * The contents of a buffer may be accessed using the @ref buffer_size
- * and @ref buffer_cast functions:
- *
- * @code boost::asio::const_buffer b1 = ...;
- * std::size_t s1 = boost::asio::buffer_size(b1);
- * const unsigned char* p1 = boost::asio::buffer_cast<const unsigned char*>(b1);
- * @endcode
- *
- * The boost::asio::buffer_cast function permits violations of type safety, so
- * uses of it in application code should be carefully considered.
  */
 class const_buffer
 {
 public:
   /// Construct an empty buffer.
   const_buffer()
     : data_(0),
       size_(0)
   {
   }
 
   /// Construct a buffer to represent a given memory range.
   const_buffer(const void* data, std::size_t size)
     : data_(data),
       size_(size)
   {
   }
 
   /// Construct a non-modifiable buffer from a modifiable one.
   const_buffer(const mutable_buffer& b)
     : data_(boost::asio::detail::buffer_cast_helper(b)),
       size_(boost::asio::detail::buffer_size_helper(b))
 #if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)
       , debug_check_(b.get_debug_check())
 #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)
     : data_(data),
       size_(size),
       debug_check_(debug_check)
   {
@@ -245,420 +271,295 @@ public:
   }
 #endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING
 
 private:
   friend const void* boost::asio::detail::buffer_cast_helper(
       const const_buffer& b);
   friend std::size_t boost::asio::detail::buffer_size_helper(
       const const_buffer& b);
 
   const void* data_;
   std::size_t size_;
 
 #if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)
   boost::function<void()> debug_check_;
 #endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING
 };
 
 namespace detail {
 
 inline const void* buffer_cast_helper(const const_buffer& b)
 {
 #if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)
   if (b.size_ && b.debug_check_)
     b.debug_check_();
 #endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING
   return b.data_;
 }
 
 inline std::size_t buffer_size_helper(const const_buffer& b)
 {
   return b.size_;
 }
 
 } // namespace detail
 
+/// Cast a non-modifiable buffer to a specified pointer to POD type.
+/**
+ * @relates const_buffer
+ */
+template <typename PointerToPodType>
+inline PointerToPodType buffer_cast(const const_buffer& b)
+{
+  return static_cast<PointerToPodType>(detail::buffer_cast_helper(b));
+}
+
+/// Get the number of bytes in a non-modifiable buffer.
+/**
+ * @relates const_buffer
+ */
+inline std::size_t buffer_size(const const_buffer& b)
+{
+  return detail::buffer_size_helper(b);
+}
+
+/// Create a new non-modifiable buffer that is offset from the start of another.
+/**
+ * @relates const_buffer
+ */
+inline const_buffer operator+(const const_buffer& b, std::size_t start)
+{
+  if (start > buffer_size(b))
+    return const_buffer();
+  const char* new_data = buffer_cast<const char*>(b) + start;
+  std::size_t new_size = buffer_size(b) - start;
+  return const_buffer(new_data, new_size
+#if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)
+      , b.get_debug_check()
+#endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING
+      );
+}
+
+/// Create a new non-modifiable buffer that is offset from the start of another.
+/**
+ * @relates const_buffer
+ */
+inline const_buffer operator+(std::size_t start, const const_buffer& b)
+{
+  if (start > buffer_size(b))
+    return const_buffer();
+  const char* new_data = buffer_cast<const char*>(b) + start;
+  std::size_t new_size = buffer_size(b) - start;
+  return const_buffer(new_data, new_size
+#if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)
+      , b.get_debug_check()
+#endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING
+      );
+}
+
 /// Adapts a single non-modifiable buffer so that it meets the requirements of
 /// the ConstBufferSequence concept.
 class const_buffers_1
   : public const_buffer
 {
 public:
   /// The type for each element in the list of buffers.
   typedef const_buffer value_type;
 
   /// A random-access iterator type that may be used to read elements.
   typedef const const_buffer* const_iterator;
 
   /// Construct to represent a given memory range.
   const_buffers_1(const void* data, std::size_t size)
     : const_buffer(data, size)
   {
   }
 
   /// Construct to represent a single non-modifiable buffer.
   explicit const_buffers_1(const const_buffer& b)
     : const_buffer(b)
   {
   }
 
   /// Get a random-access iterator to the first element.
   const_iterator begin() const
   {
     return this;
   }
 
   /// Get a random-access iterator for one past the last element.
   const_iterator end() const
   {
     return begin() + 1;
   }
 };
 
 /// An implementation of both the ConstBufferSequence and MutableBufferSequence
 /// concepts to represent a null buffer sequence.
 class null_buffers
 {
 public:
   /// The type for each element in the list of buffers.
   typedef mutable_buffer value_type;
 
   /// A random-access iterator type that may be used to read elements.
   typedef const mutable_buffer* const_iterator;
 
   /// Get a random-access iterator to the first element.
   const_iterator begin() const
   {
     return &buf_;
   }
 
   /// Get a random-access iterator for one past the last element.
   const_iterator end() const
   {
     return &buf_;
   }
 
 private:
   mutable_buffer buf_;
 };
 
-/** @defgroup buffer_size boost::asio::buffer_size
- *
- * @brief The boost::asio::buffer_size function determines the total number of
- * bytes in a buffer or buffer sequence.
- */
-/*@{*/
-
-/// Get the number of bytes in a modifiable buffer.
-inline std::size_t buffer_size(const mutable_buffer& b)
-{
-  return detail::buffer_size_helper(b);
-}
-
-/// Get the number of bytes in a modifiable buffer.
-inline std::size_t buffer_size(const mutable_buffers_1& b)
-{
-  return detail::buffer_size_helper(b);
-}
-
-/// Get the number of bytes in a non-modifiable buffer.
-inline std::size_t buffer_size(const const_buffer& b)
-{
-  return detail::buffer_size_helper(b);
-}
-
-/// Get the number of bytes in a non-modifiable buffer.
-inline std::size_t buffer_size(const const_buffers_1& b)
-{
-  return detail::buffer_size_helper(b);
-}
-
-/// Get the total number of bytes in a buffer sequence.
-/** 
- * The @c BufferSequence template parameter may meet either of the @c
- * ConstBufferSequence or @c MutableBufferSequence type requirements.
- */
-template <typename BufferSequence>
-inline std::size_t buffer_size(const BufferSequence& b)
-{
-  std::size_t total_buffer_size = 0;
-
-  typename BufferSequence::const_iterator iter = b.begin();
-  typename BufferSequence::const_iterator end = b.end();
-  for (; iter != end; ++iter)
-    total_buffer_size += detail::buffer_size_helper(*iter);
-
-  return total_buffer_size;
-}
-
-/*@}*/
-
-/** @defgroup buffer_cast boost::asio::buffer_cast
- *
- * @brief The boost::asio::buffer_cast function is used to obtain a pointer to
- * the underlying memory region associated with a buffer.
- *
- * @par Examples:
- *
- * To access the memory of a non-modifiable buffer, use:
- * @code boost::asio::const_buffer b1 = ...;
- * const unsigned char* p1 = boost::asio::buffer_cast<const unsigned char*>(b1);
- * @endcode
- *
- * To access the memory of a modifiable buffer, use:
- * @code boost::asio::mutable_buffer b2 = ...;
- * unsigned char* p2 = boost::asio::buffer_cast<unsigned char*>(b2);
- * @endcode
- *
- * The boost::asio::buffer_cast function permits violations of type safety, so
- * uses of it in application code should be carefully considered.
- */
-/*@{*/
-
-/// Cast a non-modifiable buffer to a specified pointer to POD type.
-template <typename PointerToPodType>
-inline PointerToPodType buffer_cast(const mutable_buffer& b)
-{
-  return static_cast<PointerToPodType>(detail::buffer_cast_helper(b));
-}
-
-/// Cast a non-modifiable buffer to a specified pointer to POD type.
-template <typename PointerToPodType>
-inline PointerToPodType buffer_cast(const const_buffer& b)
-{
-  return static_cast<PointerToPodType>(detail::buffer_cast_helper(b));
-}
-
-/*@}*/
-
-/// Create a new modifiable buffer that is offset from the start of another.
-/**
- * @relates mutable_buffer
- */
-inline mutable_buffer operator+(const mutable_buffer& b, std::size_t start)
-{
-  if (start > buffer_size(b))
-    return mutable_buffer();
-  char* new_data = buffer_cast<char*>(b) + start;
-  std::size_t new_size = buffer_size(b) - start;
-  return mutable_buffer(new_data, new_size
-#if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)
-      , b.get_debug_check()
-#endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING
-      );
-}
-
-/// Create a new modifiable buffer that is offset from the start of another.
-/**
- * @relates mutable_buffer
- */
-inline mutable_buffer operator+(std::size_t start, const mutable_buffer& b)
-{
-  if (start > buffer_size(b))
-    return mutable_buffer();
-  char* new_data = buffer_cast<char*>(b) + start;
-  std::size_t new_size = buffer_size(b) - start;
-  return mutable_buffer(new_data, new_size
-#if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)
-      , b.get_debug_check()
-#endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING
-      );
-}
-
-/// Create a new non-modifiable buffer that is offset from the start of another.
-/**
- * @relates const_buffer
- */
-inline const_buffer operator+(const const_buffer& b, std::size_t start)
-{
-  if (start > buffer_size(b))
-    return const_buffer();
-  const char* new_data = buffer_cast<const char*>(b) + start;
-  std::size_t new_size = buffer_size(b) - start;
-  return const_buffer(new_data, new_size
-#if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)
-      , b.get_debug_check()
-#endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING
-      );
-}
-
-/// Create a new non-modifiable buffer that is offset from the start of another.
-/**
- * @relates const_buffer
- */
-inline const_buffer operator+(std::size_t start, const const_buffer& b)
-{
-  if (start > buffer_size(b))
-    return const_buffer();
-  const char* new_data = buffer_cast<const char*>(b) + start;
-  std::size_t new_size = buffer_size(b) - start;
-  return const_buffer(new_data, new_size
-#if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)
-      , b.get_debug_check()
-#endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING
-      );
-}
-
 #if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)
 namespace detail {
 
 template <typename Iterator>
 class buffer_debug_check
 {
 public:
   buffer_debug_check(Iterator iter)
     : iter_(iter)
   {
   }
 
   ~buffer_debug_check()
   {
 #if BOOST_WORKAROUND(BOOST_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)
   }
 
   void operator()()
   {
     *iter_;
   }
 
 private:
   Iterator iter_;
 };
 
 } // namespace detail
 #endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING
 
 /** @defgroup buffer boost::asio::buffer
  *
  * @brief The boost::asio::buffer function is used to create a buffer object to
  * represent raw memory, an array of POD elements, a vector of POD elements,
  * or a std::string.
  *
  * A buffer object represents a contiguous region of memory as a 2-tuple
  * consisting of a pointer and size in bytes. A tuple of the form <tt>{void*,
  * size_t}</tt> specifies a mutable (modifiable) region of memory. Similarly, a
  * tuple of the form <tt>{const void*, size_t}</tt> specifies a const
  * (non-modifiable) region of memory. These two forms correspond to the classes
  * mutable_buffer and const_buffer, respectively. To mirror C++'s conversion
  * rules, a mutable_buffer is implicitly convertible to a const_buffer, and the
  * opposite conversion is not permitted.
  *
  * The simplest use case involves reading or writing a single buffer of a
  * specified size:
  *
  * @code sock.send(boost::asio::buffer(data, size)); @endcode
  *
  * In the above example, the return value of boost::asio::buffer meets the
  * requirements of the ConstBufferSequence concept so that it may be directly
  * passed to the socket's write function. A buffer created for modifiable
  * memory also meets the requirements of the MutableBufferSequence concept.
  *
- * An individual buffer may be created from a builtin array, std::vector,
- * std::array or boost::array of POD elements. This helps prevent buffer
- * overruns by automatically determining the size of the buffer:
+ * An individual buffer may be created from a builtin array, std::vector or
+ * boost::array of POD elements. This helps prevent buffer overruns by
+ * automatically determining the size of the buffer:
  *
  * @code char d1[128];
  * size_t bytes_transferred = sock.receive(boost::asio::buffer(d1));
  *
  * std::vector<char> d2(128);
  * bytes_transferred = sock.receive(boost::asio::buffer(d2));
  *
- * std::array<char, 128> d3;
- * bytes_transferred = sock.receive(boost::asio::buffer(d3));
- *
- * boost::array<char, 128> d4;
- * bytes_transferred = sock.receive(boost::asio::buffer(d4)); @endcode
+ * boost::array<char, 128> d3;
+ * bytes_transferred = sock.receive(boost::asio::buffer(d3)); @endcode
  *
  * In all three cases above, the buffers created are exactly 128 bytes long.
  * Note that a vector is @e never automatically resized when creating or using
  * a buffer. The buffer size is determined using the vector's <tt>size()</tt>
  * member function, and not its capacity.
  *
  * @par Accessing Buffer Contents
  *
- * The contents of a buffer may be accessed using the @ref buffer_size and
- * @ref buffer_cast functions:
+ * The contents of a buffer may be accessed using the boost::asio::buffer_size
+ * and boost::asio::buffer_cast functions:
  *
  * @code boost::asio::mutable_buffer b1 = ...;
  * std::size_t s1 = boost::asio::buffer_size(b1);
  * unsigned char* p1 = boost::asio::buffer_cast<unsigned char*>(b1);
  *
  * boost::asio::const_buffer b2 = ...;
  * std::size_t s2 = boost::asio::buffer_size(b2);
  * const void* p2 = boost::asio::buffer_cast<const void*>(b2); @endcode
  *
  * The boost::asio::buffer_cast function permits violations of type safety, so
  * uses of it in application code should be carefully considered.
  *
- * For convenience, the @ref buffer_size function also works on buffer
- * sequences (that is, types meeting the ConstBufferSequence or
- * MutableBufferSequence type requirements). In this case, the function returns
- * the total size of all buffers in the sequence.
- *
- * @par Buffer Copying
- *
- * The @ref buffer_copy function may be used to copy raw bytes between
- * individual buffers and buffer sequences.
- *
- * In particular, when used with the @ref buffer_size, the @ref buffer_copy
- * function can be used to linearise a sequence of buffers. For example:
- *
- * @code vector<const_buffer> buffers = ...;
- *
- * vector<unsigned char> data(boost::asio::buffer_size(buffers));
- * boost::asio::buffer_copy(boost::asio::buffer(data), buffers); @endcode
- *
  * @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.
  *
  * For the boost::asio::buffer overloads that accept an argument of type
  * std::vector, the buffer objects returned are invalidated by any vector
  * operation that also invalidates all references, pointers and iterators
  * referring to the elements in the sequence (C++ Std, 23.2.4)
  *
  * For the boost::asio::buffer overloads that accept an argument of type
- * std::basic_string, the buffer objects returned are invalidated according to
- * the rules defined for invalidation of references, pointers and iterators
+ * std::string, the buffer objects returned are invalidated according to the
+ * rules defined for invalidation of references, pointers and iterators
  * referring to elements of the sequence (C++ Std, 21.3).
  *
  * @par Buffer Arithmetic
  *
  * Buffer objects may be manipulated using simple arithmetic in a safe way
  * which helps prevent buffer overruns. Consider an array initialised as
  * follows:
  *
  * @code boost::array<char, 6> a = { 'a', 'b', 'c', 'd', 'e' }; @endcode
  *
  * A buffer object @c b1 created using:
  *
  * @code b1 = boost::asio::buffer(a); @endcode
  *
  * represents the entire array, <tt>{ 'a', 'b', 'c', 'd', 'e' }</tt>. An
  * optional second argument to the boost::asio::buffer function may be used to
  * limit the size, in bytes, of the buffer:
  *
  * @code b2 = boost::asio::buffer(a, 3); @endcode
  *
  * such that @c b2 represents the data <tt>{ 'a', 'b', 'c' }</tt>. Even if the
  * size argument exceeds the actual size of the array, the size of the buffer
  * object created will be limited to the array size.
  *
  * An offset may be applied to an existing buffer to create a new one:
  *
  * @code b3 = b1 + 2; @endcode
  *
  * where @c b3 will set to represent <tt>{ 'c', 'd', 'e' }</tt>. If the offset
  * exceeds the size of the existing buffer, the newly created buffer will be
  * empty.
  *
  * Both an offset and size may be specified to create a buffer that corresponds
  * to a specific range of bytes within an existing buffer:
  *
@@ -963,167 +864,70 @@ inline const_buffers_1 buffer(boost::array<const PodType, N>& data,
 
 #endif // BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x582))
        // || BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590))
 
 /// 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(),
  *     data.size() * sizeof(PodType)); @endcode
  */
 template <typename PodType, std::size_t N>
 inline const_buffers_1 buffer(const boost::array<PodType, N>& data)
 {
   return const_buffers_1(
       const_buffer(data.data(), data.size() * sizeof(PodType)));
 }
 
 /// 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(),
  *     min(data.size() * sizeof(PodType), max_size_in_bytes)); @endcode
  */
 template <typename PodType, std::size_t N>
 inline const_buffers_1 buffer(const boost::array<PodType, N>& data,
     std::size_t max_size_in_bytes)
 {
   return const_buffers_1(
       const_buffer(data.data(),
         data.size() * sizeof(PodType) < max_size_in_bytes
         ? data.size() * sizeof(PodType) : max_size_in_bytes));
 }
 
-#if defined(BOOST_ASIO_HAS_STD_ARRAY) || defined(GENERATING_DOCUMENTATION)
-
-/// 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(),
- *     data.size() * sizeof(PodType)); @endcode
- */
-template <typename PodType, std::size_t N>
-inline mutable_buffers_1 buffer(std::array<PodType, N>& data)
-{
-  return mutable_buffers_1(
-      mutable_buffer(data.data(), data.size() * sizeof(PodType)));
-}
-
-/// 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(),
- *     min(data.size() * sizeof(PodType), max_size_in_bytes)); @endcode
- */
-template <typename PodType, std::size_t N>
-inline mutable_buffers_1 buffer(std::array<PodType, N>& data,
-    std::size_t max_size_in_bytes)
-{
-  return mutable_buffers_1(
-      mutable_buffer(data.data(),
-        data.size() * sizeof(PodType) < max_size_in_bytes
-        ? data.size() * sizeof(PodType) : max_size_in_bytes));
-}
-
-/// 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(),
- *     data.size() * sizeof(PodType)); @endcode
- */
-template <typename PodType, std::size_t N>
-inline const_buffers_1 buffer(std::array<const PodType, N>& data)
-{
-  return const_buffers_1(
-      const_buffer(data.data(), data.size() * sizeof(PodType)));
-}
-
-/// 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(),
- *     min(data.size() * sizeof(PodType), max_size_in_bytes)); @endcode
- */
-template <typename PodType, std::size_t N>
-inline const_buffers_1 buffer(std::array<const PodType, N>& data,
-    std::size_t max_size_in_bytes)
-{
-  return const_buffers_1(
-      const_buffer(data.data(),
-        data.size() * sizeof(PodType) < max_size_in_bytes
-        ? data.size() * sizeof(PodType) : max_size_in_bytes));
-}
-
-/// 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(),
- *     data.size() * sizeof(PodType)); @endcode
- */
-template <typename PodType, std::size_t N>
-inline const_buffers_1 buffer(const std::array<PodType, N>& data)
-{
-  return const_buffers_1(
-      const_buffer(data.data(), data.size() * sizeof(PodType)));
-}
-
-/// 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(),
- *     min(data.size() * sizeof(PodType), max_size_in_bytes)); @endcode
- */
-template <typename PodType, std::size_t N>
-inline const_buffers_1 buffer(const std::array<PodType, N>& data,
-    std::size_t max_size_in_bytes)
-{
-  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 // defined(BOOST_ASIO_HAS_STD_ARRAY) || defined(GENERATING_DOCUMENTATION)
-
 /// Create a new modifiable buffer that represents the given POD vector.
 /**
  * @returns A mutable_buffers_1 value equivalent to:
  * @code mutable_buffers_1(
  *     data.size() ? &data[0] : 0,
  *     data.size() * sizeof(PodType)); @endcode
  *
  * @note The buffer is invalidated by any vector operation that would also
  * invalidate iterators.
  */
 template <typename PodType, typename Allocator>
 inline mutable_buffers_1 buffer(std::vector<PodType, Allocator>& data)
 {
   return mutable_buffers_1(
       mutable_buffer(data.size() ? &data[0] : 0, data.size() * sizeof(PodType)
 #if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)
         , detail::buffer_debug_check<
             typename std::vector<PodType, Allocator>::iterator
           >(data.begin())
 #endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING
         ));
 }
 
 /// Create a new modifiable buffer that represents the given POD vector.
 /**
  * @returns A mutable_buffers_1 value equivalent to:
  * @code mutable_buffers_1(
  *     data.size() ? &data[0] : 0,
  *     min(data.size() * sizeof(PodType), max_size_in_bytes)); @endcode
  *
  * @note The buffer is invalidated by any vector operation that would also
  * invalidate iterators.
  */
 template <typename PodType, typename Allocator>
 inline mutable_buffers_1 buffer(std::vector<PodType, Allocator>& data,
@@ -1161,982 +965,80 @@ inline const_buffers_1 buffer(
         , detail::buffer_debug_check<
             typename std::vector<PodType, Allocator>::const_iterator
           >(data.begin())
 #endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING
         ));
 }
 
 /// Create a new non-modifiable buffer that represents the given POD vector.
 /**
  * @returns A const_buffers_1 value equivalent to:
  * @code const_buffers_1(
  *     data.size() ? &data[0] : 0,
  *     min(data.size() * sizeof(PodType), max_size_in_bytes)); @endcode
  *
  * @note The buffer is invalidated by any vector operation that would also
  * invalidate iterators.
  */
 template <typename PodType, typename Allocator>
 inline const_buffers_1 buffer(
     const std::vector<PodType, Allocator>& data, std::size_t max_size_in_bytes)
 {
   return const_buffers_1(
       const_buffer(data.size() ? &data[0] : 0,
         data.size() * sizeof(PodType) < max_size_in_bytes
         ? data.size() * sizeof(PodType) : max_size_in_bytes
 #if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)
         , detail::buffer_debug_check<
             typename std::vector<PodType, Allocator>::const_iterator
           >(data.begin())
 #endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING
         ));
 }
 
 /// Create a new non-modifiable buffer that represents the given string.
 /**
- * @returns <tt>const_buffers_1(data.data(), data.size() * sizeof(Elem))</tt>.
+ * @returns <tt>const_buffers_1(data.data(), data.size())</tt>.
  *
  * @note The buffer is invalidated by any non-const operation called on the
  * given string object.
  */
-template <typename Elem, typename Traits, typename Allocator>
-inline const_buffers_1 buffer(
-    const std::basic_string<Elem, Traits, Allocator>& data)
+inline const_buffers_1 buffer(const std::string& data)
 {
-  return const_buffers_1(const_buffer(data.data(), data.size() * sizeof(Elem)
+  return const_buffers_1(const_buffer(data.data(), data.size()
 #if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)
-        , detail::buffer_debug_check<
-            typename std::basic_string<Elem, Traits, Allocator>::const_iterator
-          >(data.begin())
+        , detail::buffer_debug_check<std::string::const_iterator>(data.begin())
 #endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING
         ));
 }
 
 /// Create a new non-modifiable buffer that represents the given string.
 /**
  * @returns A const_buffers_1 value equivalent to:
  * @code const_buffers_1(
  *     data.data(),
- *     min(data.size() * sizeof(Elem), max_size_in_bytes)); @endcode
+ *     min(data.size(), max_size_in_bytes)); @endcode
  *
  * @note The buffer is invalidated by any non-const operation called on the
  * given string object.
  */
-template <typename Elem, typename Traits, typename Allocator>
-inline const_buffers_1 buffer(
-    const std::basic_string<Elem, Traits, Allocator>& data,
+inline const_buffers_1 buffer(const std::string& data,
     std::size_t max_size_in_bytes)
 {
   return const_buffers_1(
       const_buffer(data.data(),
-        data.size() * sizeof(Elem) < max_size_in_bytes
-        ? data.size() * sizeof(Elem) : max_size_in_bytes
+        data.size() < max_size_in_bytes
+        ? data.size() : max_size_in_bytes
 #if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)
-        , detail::buffer_debug_check<
-            typename std::basic_string<Elem, Traits, Allocator>::const_iterator
-          >(data.begin())
+        , detail::buffer_debug_check<std::string::const_iterator>(data.begin())
 #endif // BOOST_ASIO_ENABLE_BUFFER_DEBUGGING
         ));
 }
 
 /*@}*/
 
-/** @defgroup buffer_copy boost::asio::buffer_copy
- *
- * @brief The boost::asio::buffer_copy function is used to copy bytes from a
- * source buffer (or buffer sequence) to a target buffer (or buffer sequence).
- *
- * The @c buffer_copy function is available in two forms:
- *
- * @li A 2-argument form: @c buffer_copy(target, source)
- *
- * @li A 3-argument form: @c buffer_copy(target, source, max_bytes_to_copy)
-
- * Both forms return the number of bytes actually copied. The number of bytes
- * copied is the lesser of:
- *
- * @li @c buffer_size(target)
- *
- * @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.
- */
-/*@{*/
-
-/// Copies bytes from a source buffer to a target buffer.
-/**
- * @param target A modifiable buffer representing the memory region to which
- * the bytes will be copied.
- *
- * @param source A non-modifiable buffer representing the memory region from
- * which the bytes will be copied.
- *
- * @returns The number of bytes copied.
- *
- * @note The number of bytes copied is the lesser of:
- *
- * @li @c buffer_size(target)
- *
- * @li @c buffer_size(source)
- */
-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);
-  std::size_t source_size = buffer_size(source);
-  std::size_t n = target_size < source_size ? target_size : source_size;
-  memcpy(buffer_cast<void*>(target), buffer_cast<const void*>(source), n);
-  return n;
-}
-
-/// Copies bytes from a source buffer to a target buffer.
-/**
- * @param target A modifiable buffer representing the memory region to which
- * the bytes will be copied.
- *
- * @param source A non-modifiable buffer representing the memory region from
- * which the bytes will be copied.
- *
- * @returns The number of bytes copied.
- *
- * @note The number of bytes copied is the lesser of:
- *
- * @li @c buffer_size(target)
- *
- * @li @c buffer_size(source)
- */
-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));
-}
-
-/// Copies bytes from a source buffer to a target buffer.
-/**
- * @param target A modifiable buffer representing the memory region to which
- * the bytes will be copied.
- *
- * @param source A modifiable buffer representing the memory region from which
- * the bytes will be copied. The contents of the source buffer will not be
- * modified.
- *
- * @returns The number of bytes copied.
- *
- * @note The number of bytes copied is the lesser of:
- *
- * @li @c buffer_size(target)
- *
- * @li @c buffer_size(source)
- */
-inline std::size_t buffer_copy(const mutable_buffer& target,
-    const mutable_buffer& source)
-{
-  return buffer_copy(target, const_buffer(source));
-}
-
-/// Copies bytes from a source buffer to a target buffer.
-/**
- * @param target A modifiable buffer representing the memory region to which
- * the bytes will be copied.
- *
- * @param source A modifiable buffer representing the memory region from which
- * the bytes will be copied. The contents of the source buffer will not be
- * modified.
- *
- * @returns The number of bytes copied.
- *
- * @note The number of bytes copied is the lesser of:
- *
- * @li @c buffer_size(target)
- *
- * @li @c buffer_size(source)
- */
-inline std::size_t buffer_copy(const mutable_buffer& target,
-    const mutable_buffers_1& source)
-{
-  return buffer_copy(target, const_buffer(source));
-}
-
-/// Copies bytes from a source buffer sequence to a target buffer.
-/**
- * @param target A modifiable buffer representing the memory region to which
- * the bytes will be copied.
- *
- * @param source A non-modifiable buffer sequence representing the memory
- * regions from which the bytes will be copied.
- *
- * @returns The number of bytes copied.
- *
- * @note The number of bytes copied is the lesser of:
- *
- * @li @c buffer_size(target)
- *
- * @li @c buffer_size(source)
- */
-template <typename ConstBufferSequence>
-std::size_t buffer_copy(const mutable_buffer& target,
-    const ConstBufferSequence& source)
-{
-  std::size_t total_bytes_copied = 0;
-
-  typename ConstBufferSequence::const_iterator source_iter = source.begin();
-  typename ConstBufferSequence::const_iterator source_end = source.end();
-
-  for (mutable_buffer target_buffer(target);
-      buffer_size(target_buffer) && source_iter != source_end; ++source_iter)
-  {
-    const_buffer source_buffer(*source_iter);
-    std::size_t bytes_copied = buffer_copy(target_buffer, source_buffer);
-    total_bytes_copied += bytes_copied;
-    target_buffer = target_buffer + bytes_copied;
-  }
-
-  return total_bytes_copied;
-}
-
-/// Copies bytes from a source buffer to a target buffer.
-/**
- * @param target A modifiable buffer representing the memory region to which
- * the bytes will be copied.
- *
- * @param source A non-modifiable buffer representing the memory region from
- * which the bytes will be copied.
- *
- * @returns The number of bytes copied.
- *
- * @note The number of bytes copied is the lesser of:
- *
- * @li @c buffer_size(target)
- *
- * @li @c buffer_size(source)
- */
-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);
-}
-
-/// Copies bytes from a source buffer to a target buffer.
-/**
- * @param target A modifiable buffer representing the memory region to which
- * the bytes will be copied.
- *
- * @param source A non-modifiable buffer representing the memory region from
- * which the bytes will be copied.
- *
- * @returns The number of bytes copied.
- *
- * @note The number of bytes copied is the lesser of:
- *
- * @li @c buffer_size(target)
- *
- * @li @c buffer_size(source)
- */
-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));
-}
-
-/// Copies bytes from a source buffer to a target buffer.
-/**
- * @param target A modifiable buffer representing the memory region to which
- * the bytes will be copied.
- *
- * @param source A modifiable buffer representing the memory region from which
- * the bytes will be copied. The contents of the source buffer will not be
- * modified.
- *
- * @returns The number of bytes copied.
- *
- * @note The number of bytes copied is the lesser of:
- *
- * @li @c buffer_size(target)
- *
- * @li @c buffer_size(source)
- */
-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));
-}
-
-/// Copies bytes from a source buffer to a target buffer.
-/**
- * @param target A modifiable buffer representing the memory region to which
- * the bytes will be copied.
- *
- * @param source A modifiable buffer representing the memory region from which
- * the bytes will be copied. The contents of the source buffer will not be
- * modified.
- *
- * @returns The number of bytes copied.
- *
- * @note The number of bytes copied is the lesser of:
- *
- * @li @c buffer_size(target)
- *
- * @li @c buffer_size(source)
- */
-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));
-}
-
-/// Copies bytes from a source buffer sequence to a target buffer.
-/**
- * @param target A modifiable buffer representing the memory region to which
- * the bytes will be copied.
- *
- * @param source A non-modifiable buffer sequence representing the memory
- * regions from which the bytes will be copied.
- *
- * @returns The number of bytes copied.
- *
- * @note The number of bytes copied is the lesser of:
- *
- * @li @c buffer_size(target)
- *
- * @li @c buffer_size(source)
- */
-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);
-}
-
-/// Copies bytes from a source buffer to a target buffer sequence.
-/**
- * @param target A modifiable buffer sequence representing the memory regions to
- * which the bytes will be copied.
- *
- * @param source A non-modifiable buffer representing the memory region from
- * which the bytes will be copied.
- *
- * @returns The number of bytes copied.
- *
- * @note The number of bytes copied is the lesser of:
- *
- * @li @c buffer_size(target)
- *
- * @li @c buffer_size(source)
- */
-template <typename MutableBufferSequence>
-std::size_t buffer_copy(const MutableBufferSequence& target,
-    const const_buffer& source)
-{
-  std::size_t total_bytes_copied = 0;
-
-  typename MutableBufferSequence::const_iterator target_iter = target.begin();
-  typename MutableBufferSequence::const_iterator target_end = target.end();
-
-  for (const_buffer source_buffer(source);
-      buffer_size(source_buffer) && target_iter != target_end; ++target_iter)
-  {
-    mutable_buffer target_buffer(*target_iter);
-    std::size_t bytes_copied = buffer_copy(target_buffer, source_buffer);
-    total_bytes_copied += bytes_copied;
-    source_buffer = source_buffer + bytes_copied;
-  }
-
-  return total_bytes_copied;
-}
-
-/// Copies bytes from a source buffer to a target buffer sequence.
-/**
- * @param target A modifiable buffer sequence representing the memory regions to
- * which the bytes will be copied.
- *
- * @param source A non-modifiable buffer representing the memory region from
- * which the bytes will be copied.
- *
- * @returns The number of bytes copied.
- *
- * @note The number of bytes copied is the lesser of:
- *
- * @li @c buffer_size(target)
- *
- * @li @c buffer_size(source)
- */
-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));
-}
-
-/// Copies bytes from a source buffer to a target buffer sequence.
-/**
- * @param target A modifiable buffer sequence representing the memory regions to
- * which the bytes will be copied.
- *
- * @param source A modifiable buffer representing the memory region from which
- * the bytes will be copied. The contents of the source buffer will not be
- * modified.
- *
- * @returns The number of bytes copied.
- *
- * @note The number of bytes copied is the lesser of:
- *
- * @li @c buffer_size(target)
- *
- * @li @c buffer_size(source)
- */
-template <typename MutableBufferSequence>
-inline std::size_t buffer_copy(const MutableBufferSequence& target,
-    const mutable_buffer& source)
-{
-  return buffer_copy(target, const_buffer(source));
-}
-
-/// Copies bytes from a source buffer to a target buffer sequence.
-/**
- * @param target A modifiable buffer sequence representing the memory regions to
- * which the bytes will be copied.
- *
- * @param source A modifiable buffer representing the memory region from which
- * the bytes will be copied. The contents of the source buffer will not be
- * modified.
- *
- * @returns The number of bytes copied.
- *
- * @note The number of bytes copied is the lesser of:
- *
- * @li @c buffer_size(target)
- *
- * @li @c buffer_size(source)
- */
-template <typename MutableBufferSequence>
-inline std::size_t buffer_copy(const MutableBufferSequence& target,
-    const mutable_buffers_1& source)
-{
-  return buffer_copy(target, const_buffer(source));
-}
-
-/// Copies bytes from a source buffer sequence to a target buffer sequence.
-/**
- * @param target A modifiable buffer sequence representing the memory regions to
- * which the bytes will be copied.
- *
- * @param source A non-modifiable buffer sequence representing the memory
- * regions from which the bytes will be copied.
- *
- * @returns The number of bytes copied.
- *
- * @note The number of bytes copied is the lesser of:
- *
- * @li @c buffer_size(target)
- *
- * @li @c buffer_size(source)
- */
-template <typename MutableBufferSequence, typename ConstBufferSequence>
-std::size_t buffer_copy(const MutableBufferSequence& target,
-    const ConstBufferSequence& source)
-{
-  std::size_t total_bytes_copied = 0;
-
-  typename MutableBufferSequence::const_iterator target_iter = target.begin();
-  typename MutableBufferSequence::const_iterator target_end = target.end();
-  std::size_t target_buffer_offset = 0;
-
-  typename ConstBufferSequence::const_iterator source_iter = source.begin();
-  typename ConstBufferSequence::const_iterator source_end = source.end();
-  std::size_t source_buffer_offset = 0;
-
-  while (target_iter != target_end && source_iter != source_end)
-  {
-    mutable_buffer target_buffer =
-      mutable_buffer(*target_iter) + target_buffer_offset;
-
-    const_buffer source_buffer =
-      const_buffer(*source_iter) + source_buffer_offset;
-
-    std::size_t bytes_copied = buffer_copy(target_buffer, source_buffer);
-    total_bytes_copied += bytes_copied;
-
-    if (bytes_copied == buffer_size(target_buffer))
-    {
-      ++target_iter;
-      target_buffer_offset = 0;
-    }
-    else
-      target_buffer_offset += bytes_copied;
-
-    if (bytes_copied == buffer_size(source_buffer))
-    {
-      ++source_iter;
-      source_buffer_offset = 0;
-    }
-    else
-      source_buffer_offset += bytes_copied;
-  }
-
-  return total_bytes_copied;
-}
-
-/// Copies a limited number of bytes from a source buffer to a target buffer.
-/**
- * @param target A modifiable buffer representing the memory region to which
- * the bytes will be copied.
- *
- * @param source A non-modifiable buffer representing the memory region from
- * which the bytes will be copied.
- *
- * @param max_bytes_to_copy The maximum number of bytes to be copied.
- *
- * @returns The number of bytes copied.
- *
- * @note The number of bytes copied is the lesser of:
- *
- * @li @c buffer_size(target)
- *
- * @li @c buffer_size(source)
- *
- * @li @c max_bytes_to_copy
- */
-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);
-}
-
-/// Copies a limited number of bytes from a source buffer to a target buffer.
-/**
- * @param target A modifiable buffer representing the memory region to which
- * the bytes will be copied.
- *
- * @param source A non-modifiable buffer representing the memory region from
- * which the bytes will be copied.
- *
- * @param max_bytes_to_copy The maximum number of bytes to be copied.
- *
- * @returns The number of bytes copied.
- *
- * @note The number of bytes copied is the lesser of:
- *
- * @li @c buffer_size(target)
- *
- * @li @c buffer_size(source)
- *
- * @li @c max_bytes_to_copy
- */
-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);
-}
-
-/// Copies a limited number of bytes from a source buffer to a target buffer.
-/**
- * @param target A modifiable buffer representing the memory region to which
- * the bytes will be copied.
- *
- * @param source A modifiable buffer representing the memory region from which
- * the bytes will be copied. The contents of the source buffer will not be
- * modified.
- *
- * @param max_bytes_to_copy The maximum number of bytes to be copied.
- *
- * @returns The number of bytes copied.
- *
- * @note The number of bytes copied is the lesser of:
- *
- * @li @c buffer_size(target)
- *
- * @li @c buffer_size(source)
- *
- * @li @c max_bytes_to_copy
- */
-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);
-}
-
-/// Copies a limited number of bytes from a source buffer to a target buffer.
-/**
- * @param target A modifiable buffer representing the memory region to which
- * the bytes will be copied.
- *
- * @param source A modifiable buffer representing the memory region from which
- * the bytes will be copied. The contents of the source buffer will not be
- * modified.
- *
- * @param max_bytes_to_copy The maximum number of bytes to be copied.
- *
- * @returns The number of bytes copied.
- *
- * @note The number of bytes copied is the lesser of:
- *
- * @li @c buffer_size(target)
- *
- * @li @c buffer_size(source)
- *
- * @li @c max_bytes_to_copy
- */
-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);
-}
-
-/// Copies a limited number of bytes from a source buffer sequence to a target
-/// buffer.
-/**
- * @param target A modifiable buffer representing the memory region to which
- * the bytes will be copied.
- *
- * @param source A non-modifiable buffer sequence representing the memory
- * regions from which the bytes will be copied.
- *
- * @param max_bytes_to_copy The maximum number of bytes to be copied.
- *
- * @returns The number of bytes copied.
- *
- * @note The number of bytes copied is the lesser of:
- *
- * @li @c buffer_size(target)
- *
- * @li @c buffer_size(source)
- *
- * @li @c max_bytes_to_copy
- */
-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);
-}
-
-/// Copies a limited number of bytes from a source buffer to a target buffer.
-/**
- * @param target A modifiable buffer representing the memory region to which
- * the bytes will be copied.
- *
- * @param source A non-modifiable buffer representing the memory region from
- * which the bytes will be copied.
- *
- * @param max_bytes_to_copy The maximum number of bytes to be copied.
- *
- * @returns The number of bytes copied.
- *
- * @note The number of bytes copied is the lesser of:
- *
- * @li @c buffer_size(target)
- *
- * @li @c buffer_size(source)
- *
- * @li @c max_bytes_to_copy
- */
-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);
-}
-
-/// Copies a limited number of bytes from a source buffer to a target buffer.
-/**
- * @param target A modifiable buffer representing the memory region to which
- * the bytes will be copied.
- *
- * @param source A non-modifiable buffer representing the memory region from
- * which the bytes will be copied.
- *
- * @param max_bytes_to_copy The maximum number of bytes to be copied.
- *
- * @returns The number of bytes copied.
- *
- * @note The number of bytes copied is the lesser of:
- *
- * @li @c buffer_size(target)
- *
- * @li @c buffer_size(source)
- *
- * @li @c max_bytes_to_copy
- */
-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);
-}
-
-/// Copies a limited number of bytes from a source buffer to a target buffer.
-/**
- * @param target A modifiable buffer representing the memory region to which
- * the bytes will be copied.
- *
- * @param source A modifiable buffer representing the memory region from which
- * the bytes will be copied. The contents of the source buffer will not be
- * modified.
- *
- * @param max_bytes_to_copy The maximum number of bytes to be copied.
- *
- * @returns The number of bytes copied.
- *
- * @note The number of bytes copied is the lesser of:
- *
- * @li @c buffer_size(target)
- *
- * @li @c buffer_size(source)
- *
- * @li @c max_bytes_to_copy
- */
-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);
-}
-
-/// Copies a limited number of bytes from a source buffer to a target buffer.
-/**
- * @param target A modifiable buffer representing the memory region to which
- * the bytes will be copied.
- *
- * @param source A modifiable buffer representing the memory region from which
- * the bytes will be copied. The contents of the source buffer will not be
- * modified.
- *
- * @param max_bytes_to_copy The maximum number of bytes to be copied.
- *
- * @returns The number of bytes copied.
- *
- * @note The number of bytes copied is the lesser of:
- *
- * @li @c buffer_size(target)
- *
- * @li @c buffer_size(source)
- *
- * @li @c max_bytes_to_copy
- */
-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);
-}
-
-/// Copies a limited number of bytes from a source buffer sequence to a target
-/// buffer.
-/**
- * @param target A modifiable buffer representing the memory region to which
- * the bytes will be copied.
- *
- * @param source A non-modifiable buffer sequence representing the memory
- * regions from which the bytes will be copied.
- *
- * @param max_bytes_to_copy The maximum number of bytes to be copied.
- *
- * @returns The number of bytes copied.
- *
- * @note The number of bytes copied is the lesser of:
- *
- * @li @c buffer_size(target)
- *
- * @li @c buffer_size(source)
- *
- * @li @c max_bytes_to_copy
- */
-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);
-}
-
-/// Copies a limited number of bytes from a source buffer to a target buffer
-/// sequence.
-/**
- * @param target A modifiable buffer sequence representing the memory regions to
- * which the bytes will be copied.
- *
- * @param source A non-modifiable buffer representing the memory region from
- * which the bytes will be copied.
- *
- * @param max_bytes_to_copy The maximum number of bytes to be copied.
- *
- * @returns The number of bytes copied.
- *
- * @note The number of bytes copied is the lesser of:
- *
- * @li @c buffer_size(target)
- *
- * @li @c buffer_size(source)
- *
- * @li @c max_bytes_to_copy
- */
-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));
-}
-
-/// Copies a limited number of bytes from a source buffer to a target buffer
-/// sequence.
-/**
- * @param target A modifiable buffer sequence representing the memory regions to
- * which the bytes will be copied.
- *
- * @param source A non-modifiable buffer representing the memory region from
- * which the bytes will be copied.
- *
- * @param max_bytes_to_copy The maximum number of bytes to be copied.
- *
- * @returns The number of bytes copied.
- *
- * @note The number of bytes copied is the lesser of:
- *
- * @li @c buffer_size(target)
- *
- * @li @c buffer_size(source)
- *
- * @li @c max_bytes_to_copy
- */
-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));
-}
-
-/// Copies a limited number of bytes from a source buffer to a target buffer
-/// sequence.
-/**
- * @param target A modifiable buffer sequence representing the memory regions to
- * which the bytes will be copied.
- *
- * @param source A modifiable buffer representing the memory region from which
- * the bytes will be copied. The contents of the source buffer will not be
- * modified.
- *
- * @param max_bytes_to_copy The maximum number of bytes to be copied.
- *
- * @returns The number of bytes copied.
- *
- * @note The number of bytes copied is the lesser of:
- *
- * @li @c buffer_size(target)
- *
- * @li @c buffer_size(source)
- *
- * @li @c max_bytes_to_copy
- */
-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));
-}
-
-/// Copies a limited number of bytes from a source buffer to a target buffer
-/// sequence.
-/**
- * @param target A modifiable buffer sequence representing the memory regions to
- * which the bytes will be copied.
- *
- * @param source A modifiable buffer representing the memory region from which
- * the bytes will be copied. The contents of the source buffer will not be
- * modified.
- *
- * @param max_bytes_to_copy The maximum number of bytes to be copied.
- *
- * @returns The number of bytes copied.
- *
- * @note The number of bytes copied is the lesser of:
- *
- * @li @c buffer_size(target)
- *
- * @li @c buffer_size(source)
- *
- * @li @c max_bytes_to_copy
- */
-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));
-}
-
-/// Copies a limited number of bytes from a source buffer sequence to a target
-/// buffer sequence.
-/**
- * @param target A modifiable buffer sequence representing the memory regions to
- * which the bytes will be copied.
- *
- * @param source A non-modifiable buffer sequence representing the memory
- * regions from which the bytes will be copied.
- *
- * @param max_bytes_to_copy The maximum number of bytes to be copied.
- *
- * @returns The number of bytes copied.
- *
- * @note The number of bytes copied is the lesser of:
- *
- * @li @c buffer_size(target)
- *
- * @li @c buffer_size(source)
- *
- * @li @c max_bytes_to_copy
- */
-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;
-
-  typename MutableBufferSequence::const_iterator target_iter = target.begin();
-  typename MutableBufferSequence::const_iterator target_end = target.end();
-  std::size_t target_buffer_offset = 0;
-
-  typename ConstBufferSequence::const_iterator source_iter = source.begin();
-  typename ConstBufferSequence::const_iterator source_end = source.end();
-  std::size_t source_buffer_offset = 0;
-
-  while (total_bytes_copied != max_bytes_to_copy
-      && target_iter != target_end && source_iter != source_end)
-  {
-    mutable_buffer target_buffer =
-      mutable_buffer(*target_iter) + target_buffer_offset;
-
-    const_buffer source_buffer =
-      const_buffer(*source_iter) + source_buffer_offset;
-
-    std::size_t bytes_copied = buffer_copy(target_buffer,
-        source_buffer, max_bytes_to_copy - total_bytes_copied);
-    total_bytes_copied += bytes_copied;
-
-    if (bytes_copied == buffer_size(target_buffer))
-    {
-      ++target_iter;
-      target_buffer_offset = 0;
-    }
-    else
-      target_buffer_offset += bytes_copied;
-
-    if (bytes_copied == buffer_size(source_buffer))
-    {
-      ++source_iter;
-      source_buffer_offset = 0;
-    }
-    else
-      source_buffer_offset += bytes_copied;
-  }
-
-  return total_bytes_copied;
-}
-
-/*@}*/
-
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // BOOST_ASIO_BUFFER_HPP
diff --git a/3rdParty/Boost/src/boost/asio/buffered_read_stream.hpp b/3rdParty/Boost/src/boost/asio/buffered_read_stream.hpp
index 3072580..af24dd6 100644
--- a/3rdParty/Boost/src/boost/asio/buffered_read_stream.hpp
+++ b/3rdParty/Boost/src/boost/asio/buffered_read_stream.hpp
@@ -1,54 +1,55 @@
 //
 // buffered_read_stream.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_BUFFERED_READ_STREAM_HPP
 #define BOOST_ASIO_BUFFERED_READ_STREAM_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 <cstring>
 #include <boost/type_traits/remove_reference.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/error.hpp>
 #include <boost/asio/io_service.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 
 /// Adds buffering to the read-related operations of a stream.
 /**
  * The buffered_read_stream class template can be used to add buffering to the
  * synchronous and asynchronous read operations of a stream.
  *
  * @par Thread Safety
  * @e Distinct @e objects: Safe.@n
  * @e Shared @e objects: Unsafe.
  *
  * @par Concepts:
  * AsyncReadStream, AsyncWriteStream, Stream, Sync_Read_Stream, 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;
 
@@ -64,70 +65,77 @@ public:
 
   /// Construct, passing the specified argument to initialise the next layer.
   template <typename Arg>
   explicit buffered_read_stream(Arg& a)
     : next_layer_(a),
       storage_(default_buffer_size)
   {
   }
 
   /// Construct, passing the specified argument to initialise the next layer.
   template <typename Arg>
   buffered_read_stream(Arg& a, std::size_t buffer_size)
     : next_layer_(a),
       storage_(buffer_size)
   {
   }
 
   /// Get a reference to the next layer.
   next_layer_type& next_layer()
   {
     return next_layer_;
   }
 
   /// Get a reference to the lowest layer.
   lowest_layer_type& lowest_layer()
   {
     return next_layer_.lowest_layer();
   }
 
   /// Get a const reference to the lowest layer.
   const lowest_layer_type& lowest_layer() const
   {
     return next_layer_.lowest_layer();
   }
 
+  /// (Deprecated: use get_io_service().) Get the io_service associated with
+  /// the object.
+  boost::asio::io_service& io_service()
+  {
+    return next_layer_.get_io_service();
+  }
+
   /// Get the io_service associated with the object.
   boost::asio::io_service& get_io_service()
   {
     return next_layer_.get_io_service();
   }
 
   /// Close the stream.
   void close()
   {
     next_layer_.close();
   }
 
   /// Close the stream.
   boost::system::error_code close(boost::system::error_code& ec)
   {
     return next_layer_.close(ec);
   }
 
   /// 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)
   {
     return next_layer_.write_some(buffers);
   }
 
   /// Write the given data to the stream. Returns the number of bytes written,
   /// or 0 if an error occurred.
   template <typename ConstBufferSequence>
   std::size_t write_some(const ConstBufferSequence& buffers,
       boost::system::error_code& ec)
   {
     return next_layer_.write_some(buffers, ec);
   }
 
@@ -187,191 +195,266 @@ public:
 
     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_;
   };
 
   /// 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));
   }
 
   /// 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)
+    typename MutableBufferSequence::const_iterator iter = buffers.begin();
+    typename MutableBufferSequence::const_iterator end = buffers.end();
+    size_t total_buffer_size = 0;
+    for (; iter != end; ++iter)
+    {
+      boost::asio::mutable_buffer buffer(*iter);
+      total_buffer_size += boost::asio::buffer_size(buffer);
+    }
+
+    if (total_buffer_size == 0)
       return 0;
 
     if (storage_.empty())
       fill();
 
     return copy(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)
+    typename MutableBufferSequence::const_iterator iter = buffers.begin();
+    typename MutableBufferSequence::const_iterator end = buffers.end();
+    size_t total_buffer_size = 0;
+    for (; iter != end; ++iter)
+    {
+      boost::asio::mutable_buffer buffer(*iter);
+      total_buffer_size += boost::asio::buffer_size(buffer);
+    }
+
+    if (total_buffer_size == 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());
+        using namespace std; // For memcpy.
+
+        std::size_t bytes_avail = storage_.size();
+        std::size_t bytes_copied = 0;
+
+        typename MutableBufferSequence::const_iterator iter = buffers_.begin();
+        typename MutableBufferSequence::const_iterator end = buffers_.end();
+        for (; iter != end && bytes_avail > 0; ++iter)
+        {
+          std::size_t max_length = buffer_size(*iter);
+          std::size_t length = (max_length < bytes_avail)
+            ? max_length : bytes_avail;
+          memcpy(buffer_cast<void*>(*iter),
+              storage_.data() + bytes_copied, length);
+          bytes_copied += length;
+          bytes_avail -= length;
+        }
+
         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_;
   };
 
   /// 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)
+    typename MutableBufferSequence::const_iterator iter = buffers.begin();
+    typename MutableBufferSequence::const_iterator end = buffers.end();
+    size_t total_buffer_size = 0;
+    for (; iter != end; ++iter)
+    {
+      boost::asio::mutable_buffer buffer(*iter);
+      total_buffer_size += boost::asio::buffer_size(buffer);
+    }
+
+    if (total_buffer_size == 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));
     }
   }
 
   /// 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);
   }
 
   /// 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);
   }
 
   /// Determine the amount of data that may be read without blocking.
   std::size_t in_avail()
   {
     return storage_.size();
   }
 
   /// Determine the amount of data that may be read without blocking.
   std::size_t in_avail(boost::system::error_code& ec)
   {
     ec = boost::system::error_code();
     return storage_.size();
   }
 
 private:
   /// Copy data out of the internal buffer to the specified target buffer.
   /// Returns the number of bytes copied.
   template <typename MutableBufferSequence>
   std::size_t copy(const MutableBufferSequence& buffers)
   {
-    std::size_t bytes_copied = boost::asio::buffer_copy(
-        buffers, storage_.data(), storage_.size());
+    using namespace std; // For memcpy.
+
+    std::size_t bytes_avail = storage_.size();
+    std::size_t bytes_copied = 0;
+
+    typename MutableBufferSequence::const_iterator iter = buffers.begin();
+    typename MutableBufferSequence::const_iterator end = buffers.end();
+    for (; iter != end && bytes_avail > 0; ++iter)
+    {
+      std::size_t max_length = buffer_size(*iter);
+      std::size_t length = (max_length < bytes_avail)
+        ? max_length : bytes_avail;
+      memcpy(buffer_cast<void*>(*iter), storage_.data() + bytes_copied, length);
+      bytes_copied += length;
+      bytes_avail -= length;
+    }
+
     storage_.consume(bytes_copied);
     return bytes_copied;
   }
 
   /// Copy data from the internal buffer to the specified target buffer, without
   /// removing the data from the internal buffer. Returns the number of bytes
   /// copied.
   template <typename MutableBufferSequence>
   std::size_t peek_copy(const MutableBufferSequence& buffers)
   {
-    return boost::asio::buffer_copy(buffers, storage_.data(), storage_.size());
+    using namespace std; // For memcpy.
+
+    std::size_t bytes_avail = storage_.size();
+    std::size_t bytes_copied = 0;
+
+    typename MutableBufferSequence::const_iterator iter = buffers.begin();
+    typename MutableBufferSequence::const_iterator end = buffers.end();
+    for (; iter != end && bytes_avail > 0; ++iter)
+    {
+      std::size_t max_length = buffer_size(*iter);
+      std::size_t length = (max_length < bytes_avail)
+        ? max_length : bytes_avail;
+      memcpy(buffer_cast<void*>(*iter), storage_.data() + bytes_copied, length);
+      bytes_copied += length;
+      bytes_avail -= length;
+    }
+
+    return bytes_copied;
   }
 
   /// The next layer.
   Stream next_layer_;
 
   // The data in the buffer.
   detail::buffered_stream_storage storage_;
 };
 
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.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..9c8a1af 100644
--- a/3rdParty/Boost/src/boost/asio/buffered_read_stream_fwd.hpp
+++ b/3rdParty/Boost/src/boost/asio/buffered_read_stream_fwd.hpp
@@ -1,27 +1,27 @@
 //
 // buffered_read_stream_fwd.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_BUFFERED_READ_STREAM_FWD_HPP
 #define BOOST_ASIO_BUFFERED_READ_STREAM_FWD_HPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 namespace boost {
 namespace asio {
 
 template <typename Stream>
 class buffered_read_stream;
 
 } // namespace asio
 } // namespace boost
 
 #endif // 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..43d21de 100644
--- a/3rdParty/Boost/src/boost/asio/buffered_stream.hpp
+++ b/3rdParty/Boost/src/boost/asio/buffered_stream.hpp
@@ -1,40 +1,40 @@
 //
 // buffered_stream.hpp
 // ~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_BUFFERED_STREAM_HPP
 #define BOOST_ASIO_BUFFERED_STREAM_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/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>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 
 /// Adds buffering to the read- and write-related operations of a stream.
 /**
  * The buffered_stream class template can be used to add buffering to the
  * synchronous and asynchronous read and write operations of a stream.
  *
  * @par Thread Safety
  * @e Distinct @e objects: Safe.@n
  * @e Shared @e objects: Unsafe.
  *
@@ -55,70 +55,77 @@ public:
   /// Construct, passing the specified argument to initialise the next layer.
   template <typename Arg>
   explicit buffered_stream(Arg& a)
     : inner_stream_impl_(a),
       stream_impl_(inner_stream_impl_)
   {
   }
 
   /// Construct, passing the specified argument to initialise the next layer.
   template <typename Arg>
   explicit buffered_stream(Arg& a, std::size_t read_buffer_size,
       std::size_t write_buffer_size)
     : inner_stream_impl_(a, write_buffer_size),
       stream_impl_(inner_stream_impl_, read_buffer_size)
   {
   }
 
   /// Get a reference to the next layer.
   next_layer_type& next_layer()
   {
     return stream_impl_.next_layer().next_layer();
   }
 
   /// Get a reference to the lowest layer.
   lowest_layer_type& lowest_layer()
   {
     return stream_impl_.lowest_layer();
   }
 
   /// Get a const reference to the lowest layer.
   const lowest_layer_type& lowest_layer() const
   {
     return stream_impl_.lowest_layer();
   }
 
+  /// (Deprecated: use get_io_service().) Get the io_service associated with
+  /// the object.
+  boost::asio::io_service& io_service()
+  {
+    return stream_impl_.get_io_service();
+  }
+
   /// Get the io_service associated with the object.
   boost::asio::io_service& get_io_service()
   {
     return stream_impl_.get_io_service();
   }
 
   /// Close the stream.
   void close()
   {
     stream_impl_.close();
   }
 
   /// Close the stream.
   boost::system::error_code close(boost::system::error_code& ec)
   {
     return stream_impl_.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()
   {
     return stream_impl_.next_layer().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)
   {
     return stream_impl_.next_layer().flush(ec);
   }
 
   /// Start an asynchronous flush.
diff --git a/3rdParty/Boost/src/boost/asio/buffered_stream_fwd.hpp b/3rdParty/Boost/src/boost/asio/buffered_stream_fwd.hpp
index 5241879..042b990 100644
--- a/3rdParty/Boost/src/boost/asio/buffered_stream_fwd.hpp
+++ b/3rdParty/Boost/src/boost/asio/buffered_stream_fwd.hpp
@@ -1,27 +1,27 @@
 //
 // buffered_stream_fwd.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_BUFFERED_STREAM_FWD_HPP
 #define BOOST_ASIO_BUFFERED_STREAM_FWD_HPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 namespace boost {
 namespace asio {
 
 template <typename Stream>
 class buffered_stream;
 
 } // namespace asio
 } // namespace boost
 
 #endif // 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..a163b13 100644
--- a/3rdParty/Boost/src/boost/asio/buffered_write_stream.hpp
+++ b/3rdParty/Boost/src/boost/asio/buffered_write_stream.hpp
@@ -1,54 +1,55 @@
 //
 // buffered_write_stream.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_BUFFERED_WRITE_STREAM_HPP
 #define BOOST_ASIO_BUFFERED_WRITE_STREAM_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 <cstring>
 #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/error.hpp>
 #include <boost/asio/io_service.hpp>
 #include <boost/asio/write.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 
 /// Adds buffering to the write-related operations of a stream.
 /**
  * The buffered_write_stream class template can be used to add buffering to the
  * synchronous and asynchronous write operations of a stream.
  *
  * @par Thread Safety
  * @e Distinct @e objects: Safe.@n
  * @e Shared @e objects: Unsafe.
  *
  * @par Concepts:
  * AsyncReadStream, AsyncWriteStream, Stream, SyncReadStream, SyncWriteStream.
  */
 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;
@@ -65,70 +66,77 @@ public:
 
   /// Construct, passing the specified argument to initialise the next layer.
   template <typename Arg>
   explicit buffered_write_stream(Arg& a)
     : next_layer_(a),
       storage_(default_buffer_size)
   {
   }
 
   /// Construct, passing the specified argument to initialise the next layer.
   template <typename Arg>
   buffered_write_stream(Arg& a, std::size_t buffer_size)
     : next_layer_(a),
       storage_(buffer_size)
   {
   }
 
   /// Get a reference to the next layer.
   next_layer_type& next_layer()
   {
     return next_layer_;
   }
 
   /// Get a reference to the lowest layer.
   lowest_layer_type& lowest_layer()
   {
     return next_layer_.lowest_layer();
   }
 
   /// Get a const reference to the lowest layer.
   const lowest_layer_type& lowest_layer() const
   {
     return next_layer_.lowest_layer();
   }
 
+  /// (Deprecated: use get_io_service().) Get the io_service associated with
+  /// the object.
+  boost::asio::io_service& io_service()
+  {
+    return next_layer_.get_io_service();
+  }
+
   /// Get the io_service associated with the object.
   boost::asio::io_service& get_io_service()
   {
     return next_layer_.get_io_service();
   }
 
   /// Close the stream.
   void close()
   {
     next_layer_.close();
   }
 
   /// Close the stream.
   boost::system::error_code close(boost::system::error_code& ec)
   {
     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;
   }
 
   /// 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_,
@@ -144,146 +152,184 @@ public:
   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_;
   };
 
   /// 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));
   }
 
   /// 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)
+    typename ConstBufferSequence::const_iterator iter = buffers.begin();
+    typename ConstBufferSequence::const_iterator end = buffers.end();
+    size_t total_buffer_size = 0;
+    for (; iter != end; ++iter)
+    {
+      boost::asio::const_buffer buffer(*iter);
+      total_buffer_size += boost::asio::buffer_size(buffer);
+    }
+
+    if (total_buffer_size == 0)
       return 0;
 
     if (storage_.size() == storage_.capacity())
       flush();
 
     return copy(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)
+    typename ConstBufferSequence::const_iterator iter = buffers.begin();
+    typename ConstBufferSequence::const_iterator end = buffers.end();
+    size_t total_buffer_size = 0;
+    for (; iter != end; ++iter)
+    {
+      boost::asio::const_buffer buffer(*iter);
+      total_buffer_size += boost::asio::buffer_size(buffer);
+    }
+
+    if (total_buffer_size == 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
       {
+        using namespace std; // For memcpy.
+
         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);
+        std::size_t bytes_copied = 0;
+
+        typename ConstBufferSequence::const_iterator iter = buffers_.begin();
+        typename ConstBufferSequence::const_iterator end = buffers_.end();
+        for (; iter != end && space_avail > 0; ++iter)
+        {
+          std::size_t bytes_avail = buffer_size(*iter);
+          std::size_t length = (bytes_avail < space_avail)
+            ? bytes_avail : space_avail;
+          storage_.resize(orig_size + bytes_copied + length);
+          memcpy(storage_.data() + orig_size + bytes_copied,
+              buffer_cast<const void*>(*iter), length);
+          bytes_copied += length;
+          space_avail -= 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_;
   };
 
   /// 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)
+    typename ConstBufferSequence::const_iterator iter = buffers.begin();
+    typename ConstBufferSequence::const_iterator end = buffers.end();
+    size_t total_buffer_size = 0;
+    for (; iter != end; ++iter)
+    {
+      boost::asio::const_buffer buffer(*iter);
+      total_buffer_size += boost::asio::buffer_size(buffer);
+    }
+
+    if (total_buffer_size == 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));
     }
   }
 
   /// 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)
   {
     return next_layer_.read_some(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)
   {
     return next_layer_.read_some(buffers, ec);
   }
 
   /// Start an asynchronous read. The buffer into which the data will be read
@@ -298,57 +344,71 @@ public:
   /// 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)
   {
     return next_layer_.peek(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)
   {
     return next_layer_.peek(buffers, ec);
   }
 
   /// Determine the amount of data that may be read without blocking.
   std::size_t in_avail()
   {
     return next_layer_.in_avail();
   }
 
   /// Determine the amount of data that may be read without blocking.
   std::size_t in_avail(boost::system::error_code& ec)
   {
     return next_layer_.in_avail(ec);
   }
 
 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)
   {
+    using namespace std; // For memcpy.
+
     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 bytes_copied = 0;
+
+    typename ConstBufferSequence::const_iterator iter = buffers.begin();
+    typename ConstBufferSequence::const_iterator end = buffers.end();
+    for (; iter != end && space_avail > 0; ++iter)
+    {
+      std::size_t bytes_avail = buffer_size(*iter);
+      std::size_t length = (bytes_avail < space_avail)
+        ? bytes_avail : space_avail;
+      storage_.resize(orig_size + bytes_copied + length);
+      memcpy(storage_.data() + orig_size + bytes_copied,
+          buffer_cast<const void*>(*iter), length);
+      bytes_copied += length;
+      space_avail -= length;
+    }
+
+    return bytes_copied;
   }
 
   /// The next layer.
   Stream next_layer_;
 
   // The data in the buffer.
   detail::buffered_stream_storage storage_;
 };
 
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.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..0590a96 100644
--- a/3rdParty/Boost/src/boost/asio/buffered_write_stream_fwd.hpp
+++ b/3rdParty/Boost/src/boost/asio/buffered_write_stream_fwd.hpp
@@ -1,27 +1,27 @@
 //
 // buffered_write_stream_fwd.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_BUFFERED_WRITE_STREAM_FWD_HPP
 #define BOOST_ASIO_BUFFERED_WRITE_STREAM_FWD_HPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 namespace boost {
 namespace asio {
 
 template <typename Stream>
 class buffered_write_stream;
 
 } // namespace asio
 } // namespace boost
 
 #endif // 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..3375361 100644
--- a/3rdParty/Boost/src/boost/asio/buffers_iterator.hpp
+++ b/3rdParty/Boost/src/boost/asio/buffers_iterator.hpp
@@ -1,215 +1,186 @@
 //
 // buffers_iterator.hpp
 // ~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_BUFFERS_ITERATOR_HPP
 #define BOOST_ASIO_BUFFERS_ITERATOR_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 <iterator>
 #include <boost/assert.hpp>
 #include <boost/detail/workaround.hpp>
+#include <boost/iterator.hpp>
 #include <boost/type_traits/is_convertible.hpp>
 #include <boost/type_traits/add_const.hpp>
 #include <boost/asio/buffer.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 
 namespace detail
 {
   template <bool IsMutable>
   struct buffers_iterator_types_helper;
 
   template <>
   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;
     };
   };
 
   template <>
   struct buffers_iterator_types_helper<true>
   {
     typedef mutable_buffer buffer_type;
     template <typename ByteType>
     struct byte_type
     {
       typedef ByteType type;
     };
   };
 
   template <typename BufferSequence, typename ByteType>
   struct buffers_iterator_types
   {
     enum
     {
       is_mutable = boost::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;
   };
 }
 
 /// A random access iterator over the bytes in a buffer sequence.
 template <typename BufferSequence, typename ByteType = char>
 class buffers_iterator
+  : public boost::iterator<
+      std::random_access_iterator_tag,
+      typename detail::buffers_iterator_types<
+        BufferSequence, ByteType>::byte_type>
 {
 private:
   typedef typename detail::buffers_iterator_types<
       BufferSequence, ByteType>::buffer_type buffer_type;
-
-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 ByteType value_type;
-
-#if defined(GENERATING_DOCUMENTATION)
-  /// The type of the result of applying operator->() to the iterator.
-  /**
-   * If the buffer sequence stores buffer objects that are convertible to
-   * mutable_buffer, this is a pointer to a non-const ByteType. Otherwise, a
-   * pointer to a const ByteType.
-   */
-  typedef const_or_non_const_ByteType* pointer;
-#else // defined(GENERATING_DOCUMENTATION)
-  typedef typename detail::buffers_iterator_types<
-      BufferSequence, ByteType>::byte_type* pointer;
-#endif // defined(GENERATING_DOCUMENTATION)
-
-#if defined(GENERATING_DOCUMENTATION)
-  /// The type of the result of applying operator*() to the iterator.
-  /**
-   * If the buffer sequence stores buffer objects that are convertible to
-   * mutable_buffer, this is a reference to a non-const ByteType. Otherwise, a
-   * reference to a const ByteType.
-   */
-  typedef const_or_non_const_ByteType& reference;
-#else // defined(GENERATING_DOCUMENTATION)
   typedef typename detail::buffers_iterator_types<
-      BufferSequence, ByteType>::byte_type& reference;
-#endif // defined(GENERATING_DOCUMENTATION)
-
-  /// The iterator category.
-  typedef std::random_access_iterator_tag iterator_category;
+      BufferSequence, ByteType>::byte_type byte_type;
 
+public:
   /// Default constructor. Creates an iterator in an undefined state.
   buffers_iterator()
     : current_buffer_(),
       current_buffer_position_(0),
       begin_(),
       current_(),
       end_(),
       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)
-    __attribute__ ((__noinline__))
+    __attribute__ ((noinline))
 #endif
   {
     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_)
     {
       new_iter.current_buffer_ = *new_iter.current_;
       if (boost::asio::buffer_size(new_iter.current_buffer_) > 0)
         break;
       ++new_iter.current_;
     }
     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)
-    __attribute__ ((__noinline__))
+    __attribute__ ((noinline))
 #endif
   {
     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_)
     {
       buffer_type buffer = *new_iter.current_;
       new_iter.position_ += boost::asio::buffer_size(buffer);
       ++new_iter.current_;
     }
     return new_iter;
   }
 
   /// Dereference an iterator.
-  reference operator*() const
+  byte_type& operator*() const
   {
     return dereference();
   }
 
   /// Dereference an iterator.
-  pointer operator->() const
+  byte_type* operator->() const
   {
     return &dereference();
   }
 
   /// Access an individual element.
-  reference operator[](std::ptrdiff_t difference) const
+  byte_type& operator[](std::ptrdiff_t difference) const
   {
     buffers_iterator tmp(*this);
     tmp.advance(difference);
     return *tmp;
   }
 
   /// Increment operator (prefix).
   buffers_iterator& operator++()
   {
     increment();
     return *this;
   }
 
   /// Increment operator (postfix).
   buffers_iterator operator++(int)
   {
     buffers_iterator tmp(*this);
     ++*this;
     return tmp;
   }
 
   /// Decrement operator (prefix).
   buffers_iterator& operator--()
   {
     decrement();
     return *this;
   }
 
   /// Decrement operator (postfix).
   buffers_iterator operator--(int)
   {
     buffers_iterator tmp(*this);
     --*this;
     return tmp;
   }
@@ -268,73 +239,73 @@ public:
     return a.equal(b);
   }
 
   /// Test two iterators for inequality.
   friend bool operator!=(const buffers_iterator& a, const buffers_iterator& b)
   {
     return !a.equal(b);
   }
 
   /// Compare two iterators.
   friend bool operator<(const buffers_iterator& a, const buffers_iterator& b)
   {
     return a.distance_to(b) > 0;
   }
 
   /// Compare two iterators.
   friend bool operator<=(const buffers_iterator& a, const buffers_iterator& b)
   {
     return !(b < a);
   }
 
   /// Compare two iterators.
   friend bool operator>(const buffers_iterator& a, const buffers_iterator& b)
   {
     return b < a;
   }
 
   /// Compare two iterators.
   friend bool operator>=(const buffers_iterator& a, const buffers_iterator& b)
   {
     return !(a < b);
   }
 
 private:
   // Dereference the iterator.
-  reference dereference() const
+  byte_type& dereference() const
   {
-    return buffer_cast<pointer>(current_buffer_)[current_buffer_position_];
+    return buffer_cast<byte_type*>(current_buffer_)[current_buffer_position_];
   }
 
   // Compare two iterators for equality.
   bool equal(const buffers_iterator& other) const
   {
     return position_ == other.position_;
   }
 
   // Increment the iterator.
   void increment()
   {
     BOOST_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;
 
     // Find the next non-empty buffer.
     ++current_;
     current_buffer_position_ = 0;
     while (current_ != end_)
     {
       current_buffer_ = *current_;
       if (boost::asio::buffer_size(current_buffer_) > 0)
         return;
       ++current_;
     }
   }
 
   // Decrement the iterator.
   void decrement()
   {
     BOOST_ASSERT(position_ > 0 && "iterator out of bounds");
diff --git a/3rdParty/Boost/src/boost/asio/completion_condition.hpp b/3rdParty/Boost/src/boost/asio/completion_condition.hpp
index 3d32c65..7f5fc09 100644
--- a/3rdParty/Boost/src/boost/asio/completion_condition.hpp
+++ b/3rdParty/Boost/src/boost/asio/completion_condition.hpp
@@ -1,40 +1,40 @@
 //
 // completion_condition.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_COMPLETION_CONDITION_HPP
 #define BOOST_ASIO_COMPLETION_CONDITION_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/push_options.hpp>
 
 namespace boost {
 namespace asio {
 
 namespace detail {
 
 // The default maximum number of bytes to transfer in a single operation.
 enum { 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;
 }
 
 // Adapt result of current completion conditions (which have a size_t result
 // where 0 means the operation is complete, and otherwise the result is the
 // maximum number of bytes to transfer on the next underlying operation).
@@ -44,92 +44,70 @@ inline std::size_t adapt_completion_condition_result(std::size_t result)
 }
 
 class transfer_all_t
 {
 public:
   typedef std::size_t result_type;
 
   template <typename Error>
   std::size_t operator()(const Error& err, std::size_t)
   {
     return !!err ? 0 : default_max_transfer_size;
   }
 };
 
 class transfer_at_least_t
 {
 public:
   typedef std::size_t result_type;
 
   explicit transfer_at_least_t(std::size_t minimum)
     : minimum_(minimum)
   {
   }
 
   template <typename Error>
   std::size_t operator()(const Error& err, std::size_t bytes_transferred)
   {
     return (!!err || bytes_transferred >= minimum_)
       ? 0 : default_max_transfer_size;
   }
 
 private:
   std::size_t minimum_;
 };
 
-class transfer_exactly_t
-{
-public:
-  typedef std::size_t result_type;
-
-  explicit transfer_exactly_t(std::size_t size)
-    : size_(size)
-  {
-  }
-
-  template <typename Error>
-  std::size_t operator()(const Error& err, std::size_t bytes_transferred)
-  {
-    return (!!err || bytes_transferred >= size_) ? 0 :
-      (size_ - bytes_transferred < default_max_transfer_size
-        ? size_ - bytes_transferred : std::size_t(default_max_transfer_size));
-  }
-
-private:
-  std::size_t size_;
-};
-
 } // namespace detail
 
 /**
  * @defgroup completion_condition Completion Condition Function Objects
  *
  * Function objects used for determining when a read or write operation should
  * complete.
  */
 /*@{*/
 
 /// Return a completion condition function object that indicates that a read or
 /// write operation should continue until all of the data has been transferred,
 /// or until an error occurs.
 /**
  * This function is used to create an object, of unspecified type, that meets
  * CompletionCondition requirements.
  *
  * @par Example
  * Reading until a buffer is full:
  * @code
  * boost::array<char, 128> buf;
  * boost::system::error_code ec;
  * std::size_t n = boost::asio::read(
  *     sock, boost::asio::buffer(buf),
  *     boost::asio::transfer_all(), ec);
  * if (ec)
  * {
  *   // An error occurred.
  * }
  * else
  * {
  *   // n == 128
  * }
  * @endcode
  */
@@ -144,77 +122,43 @@ inline detail::transfer_all_t transfer_all()
 
 /// Return a completion condition function object that indicates that a read or
 /// write operation should continue until a minimum number of bytes has been
 /// transferred, or until an error occurs.
 /**
  * This function is used to create an object, of unspecified type, that meets
  * CompletionCondition requirements.
  *
  * @par Example
  * Reading until a buffer is full or contains at least 64 bytes:
  * @code
  * boost::array<char, 128> buf;
  * boost::system::error_code ec;
  * std::size_t n = boost::asio::read(
  *     sock, boost::asio::buffer(buf),
  *     boost::asio::transfer_at_least(64), ec);
  * if (ec)
  * {
  *   // An error occurred.
  * }
  * else
  * {
  *   // n >= 64 && n <= 128
  * }
  * @endcode
  */
 #if defined(GENERATING_DOCUMENTATION)
 unspecified transfer_at_least(std::size_t minimum);
 #else
 inline detail::transfer_at_least_t transfer_at_least(std::size_t minimum)
 {
   return detail::transfer_at_least_t(minimum);
 }
 #endif
 
-/// Return a completion condition function object that indicates that a read or
-/// write operation should continue until an exact number of bytes has been
-/// transferred, or until an error occurs.
-/**
- * This function is used to create an object, of unspecified type, that meets
- * CompletionCondition requirements.
- *
- * @par Example
- * Reading until a buffer is full or contains exactly 64 bytes:
- * @code
- * boost::array<char, 128> buf;
- * boost::system::error_code ec;
- * std::size_t n = boost::asio::read(
- *     sock, boost::asio::buffer(buf),
- *     boost::asio::transfer_exactly(64), ec);
- * if (ec)
- * {
- *   // An error occurred.
- * }
- * else
- * {
- *   // n == 64
- * }
- * @endcode
- */
-#if defined(GENERATING_DOCUMENTATION)
-unspecified transfer_exactly(std::size_t size);
-#else
-inline detail::transfer_exactly_t transfer_exactly(std::size_t size)
-{
-  return detail::transfer_exactly_t(size);
-}
-#endif
-
 /*@}*/
 
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // BOOST_ASIO_COMPLETION_CONDITION_HPP
diff --git a/3rdParty/Boost/src/boost/asio/connect.hpp b/3rdParty/Boost/src/boost/asio/connect.hpp
deleted file mode 100644
index e54ea08..0000000
--- a/3rdParty/Boost/src/boost/asio/connect.hpp
+++ /dev/null
@@ -1,816 +0,0 @@
-//
-// connect.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_CONNECT_HPP
-#define BOOST_ASIO_CONNECT_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/basic_socket.hpp>
-#include <boost/asio/error.hpp>
-
-#include <boost/asio/detail/push_options.hpp>
-
-namespace boost {
-namespace asio {
-
-/**
- * @defgroup connect boost::asio::connect
- *
- * @brief Establishes a socket connection by trying each endpoint in a sequence.
- */
-/*@{*/
-
-/// Establishes a socket connection by trying each endpoint in a sequence.
-/**
- * This function attempts to connect a socket to one of a sequence of
- * endpoints. It does this by repeated calls to the socket's @c connect member
- * function, once for each endpoint in the sequence, until a connection is
- * successfully established.
- *
- * @param s The socket to be connected. If the socket is already open, it will
- * be closed.
- *
- * @param begin An iterator pointing to the start of a sequence of endpoints.
- *
- * @returns On success, an iterator denoting the successfully connected
- * endpoint. Otherwise, the end iterator.
- *
- * @throws boost::system::system_error Thrown on failure. If the sequence is
- * empty, the associated @c error_code is boost::asio::error::not_found.
- * Otherwise, contains the error from the last connection attempt.
- *
- * @note This overload assumes that a default constructed object of type @c
- * Iterator represents the end of the sequence. This is a valid assumption for
- * iterator types such as @c boost::asio::ip::tcp::resolver::iterator.
- *
- * @par Example
- * @code tcp::resolver r(io_service);
- * tcp::resolver::query q("host", "service");
- * tcp::socket s(io_service);
- * boost::asio::connect(s, r.resolve(q)); @endcode
- */
-template <typename Protocol, typename SocketService, typename Iterator>
-Iterator connect(basic_socket<Protocol, SocketService>& s, Iterator begin);
-
-/// Establishes a socket connection by trying each endpoint in a sequence.
-/**
- * This function attempts to connect a socket to one of a sequence of
- * endpoints. It does this by repeated calls to the socket's @c connect member
- * function, once for each endpoint in the sequence, until a connection is
- * successfully established.
- *
- * @param s The socket to be connected. If the socket is already open, it will
- * be closed.
- *
- * @param begin An iterator pointing to the start of a sequence of endpoints.
- *
- * @param ec Set to indicate what error occurred, if any. If the sequence is
- * empty, set to boost::asio::error::not_found. Otherwise, contains the error
- * from the last connection attempt.
- *
- * @returns On success, an iterator denoting the successfully connected
- * endpoint. Otherwise, the end iterator.
- *
- * @note This overload assumes that a default constructed object of type @c
- * Iterator represents the end of the sequence. This is a valid assumption for
- * iterator types such as @c boost::asio::ip::tcp::resolver::iterator.
- *
- * @par Example
- * @code tcp::resolver r(io_service);
- * tcp::resolver::query q("host", "service");
- * tcp::socket s(io_service);
- * boost::system::error_code ec;
- * boost::asio::connect(s, r.resolve(q), ec);
- * if (ec)
- * {
- *   // An error occurred.
- * } @endcode
- */
-template <typename Protocol, typename SocketService, typename Iterator>
-Iterator connect(basic_socket<Protocol, SocketService>& s,
-    Iterator begin, boost::system::error_code& ec);
-
-/// Establishes a socket connection by trying each endpoint in a sequence.
-/**
- * This function attempts to connect a socket to one of a sequence of
- * endpoints. It does this by repeated calls to the socket's @c connect member
- * function, once for each endpoint in the sequence, until a connection is
- * successfully established.
- *
- * @param s The socket to be connected. If the socket is already open, it will
- * be closed.
- *
- * @param begin An iterator pointing to the start of a sequence of endpoints.
- *
- * @param end An iterator pointing to the end of a sequence of endpoints.
- *
- * @returns On success, an iterator denoting the successfully connected
- * endpoint. Otherwise, the end iterator.
- *
- * @throws boost::system::system_error Thrown on failure. If the sequence is
- * empty, the associated @c error_code is boost::asio::error::not_found.
- * Otherwise, contains the error from the last connection attempt.
- *
- * @par Example
- * @code tcp::resolver r(io_service);
- * tcp::resolver::query q("host", "service");
- * tcp::resolver::iterator i = r.resolve(q), end;
- * tcp::socket s(io_service);
- * boost::asio::connect(s, i, end); @endcode
- */
-template <typename Protocol, typename SocketService, typename Iterator>
-Iterator connect(basic_socket<Protocol, SocketService>& s,
-    Iterator begin, Iterator end);
-
-/// Establishes a socket connection by trying each endpoint in a sequence.
-/**
- * This function attempts to connect a socket to one of a sequence of
- * endpoints. It does this by repeated calls to the socket's @c connect member
- * function, once for each endpoint in the sequence, until a connection is
- * successfully established.
- *
- * @param s The socket to be connected. If the socket is already open, it will
- * be closed.
- *
- * @param begin An iterator pointing to the start of a sequence of endpoints.
- *
- * @param end An iterator pointing to the end of a sequence of endpoints.
- *
- * @param ec Set to indicate what error occurred, if any. If the sequence is
- * empty, set to boost::asio::error::not_found. Otherwise, contains the error
- * from the last connection attempt.
- *
- * @returns On success, an iterator denoting the successfully connected
- * endpoint. Otherwise, the end iterator.
- *
- * @par Example
- * @code tcp::resolver r(io_service);
- * tcp::resolver::query q("host", "service");
- * tcp::resolver::iterator i = r.resolve(q), end;
- * tcp::socket s(io_service);
- * boost::system::error_code ec;
- * boost::asio::connect(s, i, end, ec);
- * if (ec)
- * {
- *   // An error occurred.
- * } @endcode
- */
-template <typename Protocol, typename SocketService, typename Iterator>
-Iterator connect(basic_socket<Protocol, SocketService>& s,
-    Iterator begin, Iterator end, boost::system::error_code& ec);
-
-/// Establishes a socket connection by trying each endpoint in a sequence.
-/**
- * This function attempts to connect a socket to one of a sequence of
- * endpoints. It does this by repeated calls to the socket's @c connect member
- * function, once for each endpoint in the sequence, until a connection is
- * successfully established.
- *
- * @param s The socket to be connected. If the socket is already open, it will
- * be closed.
- *
- * @param begin An iterator pointing to the start of a sequence of endpoints.
- *
- * @param connect_condition A function object that is called prior to each
- * connection attempt. The signature of the function object must be:
- * @code Iterator connect_condition(
- *     const boost::system::error_code& ec,
- *     Iterator next); @endcode
- * The @c ec parameter contains the result from the most recent connect
- * operation. Before the first connection attempt, @c ec is always set to
- * indicate success. The @c next parameter is an iterator pointing to the next
- * endpoint to be tried. The function object should return the next iterator,
- * but is permitted to return a different iterator so that endpoints may be
- * skipped. The implementation guarantees that the function object will never
- * be called with the end iterator.
- *
- * @returns On success, an iterator denoting the successfully connected
- * endpoint. Otherwise, the end iterator.
- *
- * @throws boost::system::system_error Thrown on failure. If the sequence is
- * empty, the associated @c error_code is boost::asio::error::not_found.
- * Otherwise, contains the error from the last connection attempt.
- *
- * @note This overload assumes that a default constructed object of type @c
- * Iterator represents the end of the sequence. This is a valid assumption for
- * iterator types such as @c boost::asio::ip::tcp::resolver::iterator.
- *
- * @par Example
- * The following connect condition function object can be used to output
- * information about the individual connection attempts:
- * @code struct my_connect_condition
- * {
- *   template <typename Iterator>
- *   Iterator operator()(
- *       const boost::system::error_code& ec,
- *       Iterator next)
- *   {
- *     if (ec) std::cout << "Error: " << ec.message() << std::endl;
- *     std::cout << "Trying: " << next->endpoint() << std::endl;
- *     return next;
- *   }
- * }; @endcode
- * It would be used with the boost::asio::connect function as follows:
- * @code tcp::resolver r(io_service);
- * tcp::resolver::query q("host", "service");
- * tcp::socket s(io_service);
- * tcp::resolver::iterator i = boost::asio::connect(
- *     s, r.resolve(q), my_connect_condition());
- * std::cout << "Connected to: " << i->endpoint() << std::endl; @endcode
- */
-template <typename Protocol, typename SocketService,
-    typename Iterator, typename ConnectCondition>
-Iterator connect(basic_socket<Protocol, SocketService>& s,
-    Iterator begin, ConnectCondition connect_condition);
-
-/// Establishes a socket connection by trying each endpoint in a sequence.
-/**
- * This function attempts to connect a socket to one of a sequence of
- * endpoints. It does this by repeated calls to the socket's @c connect member
- * function, once for each endpoint in the sequence, until a connection is
- * successfully established.
- *
- * @param s The socket to be connected. If the socket is already open, it will
- * be closed.
- *
- * @param begin An iterator pointing to the start of a sequence of endpoints.
- *
- * @param connect_condition A function object that is called prior to each
- * connection attempt. The signature of the function object must be:
- * @code Iterator connect_condition(
- *     const boost::system::error_code& ec,
- *     Iterator next); @endcode
- * The @c ec parameter contains the result from the most recent connect
- * operation. Before the first connection attempt, @c ec is always set to
- * indicate success. The @c next parameter is an iterator pointing to the next
- * endpoint to be tried. The function object should return the next iterator,
- * but is permitted to return a different iterator so that endpoints may be
- * skipped. The implementation guarantees that the function object will never
- * be called with the end iterator.
- *
- * @param ec Set to indicate what error occurred, if any. If the sequence is
- * empty, set to boost::asio::error::not_found. Otherwise, contains the error
- * from the last connection attempt.
- *
- * @returns On success, an iterator denoting the successfully connected
- * endpoint. Otherwise, the end iterator.
- *
- * @note This overload assumes that a default constructed object of type @c
- * Iterator represents the end of the sequence. This is a valid assumption for
- * iterator types such as @c boost::asio::ip::tcp::resolver::iterator.
- *
- * @par Example
- * The following connect condition function object can be used to output
- * information about the individual connection attempts:
- * @code struct my_connect_condition
- * {
- *   template <typename Iterator>
- *   Iterator operator()(
- *       const boost::system::error_code& ec,
- *       Iterator next)
- *   {
- *     if (ec) std::cout << "Error: " << ec.message() << std::endl;
- *     std::cout << "Trying: " << next->endpoint() << std::endl;
- *     return next;
- *   }
- * }; @endcode
- * It would be used with the boost::asio::connect function as follows:
- * @code tcp::resolver r(io_service);
- * tcp::resolver::query q("host", "service");
- * tcp::socket s(io_service);
- * boost::system::error_code ec;
- * tcp::resolver::iterator i = boost::asio::connect(
- *     s, r.resolve(q), my_connect_condition(), ec);
- * if (ec)
- * {
- *   // An error occurred.
- * }
- * else
- * {
- *   std::cout << "Connected to: " << i->endpoint() << std::endl;
- * } @endcode
- */
-template <typename Protocol, typename SocketService,
-    typename Iterator, typename ConnectCondition>
-Iterator connect(basic_socket<Protocol, SocketService>& s, Iterator begin,
-    ConnectCondition connect_condition, boost::system::error_code& ec);
-
-/// Establishes a socket connection by trying each endpoint in a sequence.
-/**
- * This function attempts to connect a socket to one of a sequence of
- * endpoints. It does this by repeated calls to the socket's @c connect member
- * function, once for each endpoint in the sequence, until a connection is
- * successfully established.
- *
- * @param s The socket to be connected. If the socket is already open, it will
- * be closed.
- *
- * @param begin An iterator pointing to the start of a sequence of endpoints.
- *
- * @param end An iterator pointing to the end of a sequence of endpoints.
- *
- * @param connect_condition A function object that is called prior to each
- * connection attempt. The signature of the function object must be:
- * @code Iterator connect_condition(
- *     const boost::system::error_code& ec,
- *     Iterator next); @endcode
- * The @c ec parameter contains the result from the most recent connect
- * operation. Before the first connection attempt, @c ec is always set to
- * indicate success. The @c next parameter is an iterator pointing to the next
- * endpoint to be tried. The function object should return the next iterator,
- * but is permitted to return a different iterator so that endpoints may be
- * skipped. The implementation guarantees that the function object will never
- * be called with the end iterator.
- *
- * @returns On success, an iterator denoting the successfully connected
- * endpoint. Otherwise, the end iterator.
- *
- * @throws boost::system::system_error Thrown on failure. If the sequence is
- * empty, the associated @c error_code is boost::asio::error::not_found.
- * Otherwise, contains the error from the last connection attempt.
- *
- * @par Example
- * The following connect condition function object can be used to output
- * information about the individual connection attempts:
- * @code struct my_connect_condition
- * {
- *   template <typename Iterator>
- *   Iterator operator()(
- *       const boost::system::error_code& ec,
- *       Iterator next)
- *   {
- *     if (ec) std::cout << "Error: " << ec.message() << std::endl;
- *     std::cout << "Trying: " << next->endpoint() << std::endl;
- *     return next;
- *   }
- * }; @endcode
- * It would be used with the boost::asio::connect function as follows:
- * @code tcp::resolver r(io_service);
- * tcp::resolver::query q("host", "service");
- * tcp::resolver::iterator i = r.resolve(q), end;
- * tcp::socket s(io_service);
- * i = boost::asio::connect(s, i, end, my_connect_condition());
- * std::cout << "Connected to: " << i->endpoint() << std::endl; @endcode
- */
-template <typename Protocol, typename SocketService,
-    typename Iterator, typename ConnectCondition>
-Iterator connect(basic_socket<Protocol, SocketService>& s, Iterator begin,
-    Iterator end, ConnectCondition connect_condition);
-
-/// Establishes a socket connection by trying each endpoint in a sequence.
-/**
- * This function attempts to connect a socket to one of a sequence of
- * endpoints. It does this by repeated calls to the socket's @c connect member
- * function, once for each endpoint in the sequence, until a connection is
- * successfully established.
- *
- * @param s The socket to be connected. If the socket is already open, it will
- * be closed.
- *
- * @param begin An iterator pointing to the start of a sequence of endpoints.
- *
- * @param end An iterator pointing to the end of a sequence of endpoints.
- *
- * @param connect_condition A function object that is called prior to each
- * connection attempt. The signature of the function object must be:
- * @code Iterator connect_condition(
- *     const boost::system::error_code& ec,
- *     Iterator next); @endcode
- * The @c ec parameter contains the result from the most recent connect
- * operation. Before the first connection attempt, @c ec is always set to
- * indicate success. The @c next parameter is an iterator pointing to the next
- * endpoint to be tried. The function object should return the next iterator,
- * but is permitted to return a different iterator so that endpoints may be
- * skipped. The implementation guarantees that the function object will never
- * be called with the end iterator.
- *
- * @param ec Set to indicate what error occurred, if any. If the sequence is
- * empty, set to boost::asio::error::not_found. Otherwise, contains the error
- * from the last connection attempt.
- *
- * @returns On success, an iterator denoting the successfully connected
- * endpoint. Otherwise, the end iterator.
- *
- * @par Example
- * The following connect condition function object can be used to output
- * information about the individual connection attempts:
- * @code struct my_connect_condition
- * {
- *   template <typename Iterator>
- *   Iterator operator()(
- *       const boost::system::error_code& ec,
- *       Iterator next)
- *   {
- *     if (ec) std::cout << "Error: " << ec.message() << std::endl;
- *     std::cout << "Trying: " << next->endpoint() << std::endl;
- *     return next;
- *   }
- * }; @endcode
- * It would be used with the boost::asio::connect function as follows:
- * @code tcp::resolver r(io_service);
- * tcp::resolver::query q("host", "service");
- * tcp::resolver::iterator i = r.resolve(q), end;
- * tcp::socket s(io_service);
- * boost::system::error_code ec;
- * i = boost::asio::connect(s, i, end, my_connect_condition(), ec);
- * if (ec)
- * {
- *   // An error occurred.
- * }
- * else
- * {
- *   std::cout << "Connected to: " << i->endpoint() << std::endl;
- * } @endcode
- */
-template <typename Protocol, typename SocketService,
-    typename Iterator, typename ConnectCondition>
-Iterator connect(basic_socket<Protocol, SocketService>& s,
-    Iterator begin, Iterator end, ConnectCondition connect_condition,
-    boost::system::error_code& ec);
-
-/*@}*/
-
-/**
- * @defgroup async_connect boost::asio::async_connect
- *
- * @brief Asynchronously establishes a socket connection by trying each
- * endpoint in a sequence.
- */
-/*@{*/
-
-/// 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
- * endpoints. It does this by repeated calls to the socket's @c async_connect
- * member function, once for each endpoint in the sequence, until a connection
- * is successfully established.
- *
- * @param s The socket to be connected. If the socket is already open, it will
- * be closed.
- *
- * @param begin An iterator pointing to the start of a sequence of endpoints.
- *
- * @param handler The handler to be called when the connect operation
- * completes. Copies will be made of the handler as required. The function
- * signature of the handler must be:
- * @code void handler(
- *   // Result of operation. if the sequence is empty, set to
- *   // boost::asio::error::not_found. Otherwise, contains the
- *   // error from the last connection attempt.
- *   const boost::system::error_code& error,
- *
- *   // On success, an iterator denoting the successfully
- *   // connected endpoint. Otherwise, the end iterator.
- *   Iterator iterator
- * ); @endcode
- * 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().
- *
- * @note This overload assumes that a default constructed object of type @c
- * Iterator represents the end of the sequence. This is a valid assumption for
- * iterator types such as @c boost::asio::ip::tcp::resolver::iterator.
- *
- * @par Example
- * @code tcp::resolver r(io_service);
- * tcp::resolver::query q("host", "service");
- * tcp::socket s(io_service);
- *
- * // ...
- *
- * r.async_resolve(q, resolve_handler);
- *
- * // ...
- *
- * void resolve_handler(
- *     const boost::system::error_code& ec,
- *     tcp::resolver::iterator i)
- * {
- *   if (!ec)
- *   {
- *     boost::asio::async_connect(s, i, connect_handler);
- *   }
- * }
- *
- * // ...
- *
- * void connect_handler(
- *     const boost::system::error_code& ec,
- *     tcp::resolver::iterator i)
- * {
- *   // ...
- * } @endcode
- */
-template <typename Protocol, typename SocketService,
-    typename Iterator, typename ComposedConnectHandler>
-void 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
- * endpoints. It does this by repeated calls to the socket's @c async_connect
- * member function, once for each endpoint in the sequence, until a connection
- * is successfully established.
- *
- * @param s The socket to be connected. If the socket is already open, it will
- * be closed.
- *
- * @param begin An iterator pointing to the start of a sequence of endpoints.
- *
- * @param end An iterator pointing to the end of a sequence of endpoints.
- *
- * @param handler The handler to be called when the connect operation
- * completes. Copies will be made of the handler as required. The function
- * signature of the handler must be:
- * @code void handler(
- *   // Result of operation. if the sequence is empty, set to
- *   // boost::asio::error::not_found. Otherwise, contains the
- *   // error from the last connection attempt.
- *   const boost::system::error_code& error,
- *
- *   // On success, an iterator denoting the successfully
- *   // connected endpoint. Otherwise, the end iterator.
- *   Iterator iterator
- * ); @endcode
- * 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().
- *
- * @par Example
- * @code tcp::resolver r(io_service);
- * tcp::resolver::query q("host", "service");
- * tcp::socket s(io_service);
- *
- * // ...
- *
- * r.async_resolve(q, resolve_handler);
- *
- * // ...
- *
- * void resolve_handler(
- *     const boost::system::error_code& ec,
- *     tcp::resolver::iterator i)
- * {
- *   if (!ec)
- *   {
- *     tcp::resolver::iterator end;
- *     boost::asio::async_connect(s, i, end, connect_handler);
- *   }
- * }
- *
- * // ...
- *
- * void connect_handler(
- *     const boost::system::error_code& ec,
- *     tcp::resolver::iterator i)
- * {
- *   // ...
- * } @endcode
- */
-template <typename Protocol, typename SocketService,
-    typename Iterator, typename ComposedConnectHandler>
-void 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.
-/**
- * This function attempts to connect a socket to one of a sequence of
- * endpoints. It does this by repeated calls to the socket's @c async_connect
- * member function, once for each endpoint in the sequence, until a connection
- * is successfully established.
- *
- * @param s The socket to be connected. If the socket is already open, it will
- * be closed.
- *
- * @param begin An iterator pointing to the start of a sequence of endpoints.
- *
- * @param connect_condition A function object that is called prior to each
- * connection attempt. The signature of the function object must be:
- * @code Iterator connect_condition(
- *     const boost::system::error_code& ec,
- *     Iterator next); @endcode
- * The @c ec parameter contains the result from the most recent connect
- * operation. Before the first connection attempt, @c ec is always set to
- * indicate success. The @c next parameter is an iterator pointing to the next
- * endpoint to be tried. The function object should return the next iterator,
- * but is permitted to return a different iterator so that endpoints may be
- * skipped. The implementation guarantees that the function object will never
- * be called with the end iterator.
- *
- * @param handler The handler to be called when the connect operation
- * completes. Copies will be made of the handler as required. The function
- * signature of the handler must be:
- * @code void handler(
- *   // Result of operation. if the sequence is empty, set to
- *   // boost::asio::error::not_found. Otherwise, contains the
- *   // error from the last connection attempt.
- *   const boost::system::error_code& error,
- *
- *   // On success, an iterator denoting the successfully
- *   // connected endpoint. Otherwise, the end iterator.
- *   Iterator iterator
- * ); @endcode
- * 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().
- *
- * @note This overload assumes that a default constructed object of type @c
- * Iterator represents the end of the sequence. This is a valid assumption for
- * iterator types such as @c boost::asio::ip::tcp::resolver::iterator.
- *
- * @par Example
- * The following connect condition function object can be used to output
- * information about the individual connection attempts:
- * @code struct my_connect_condition
- * {
- *   template <typename Iterator>
- *   Iterator operator()(
- *       const boost::system::error_code& ec,
- *       Iterator next)
- *   {
- *     if (ec) std::cout << "Error: " << ec.message() << std::endl;
- *     std::cout << "Trying: " << next->endpoint() << std::endl;
- *     return next;
- *   }
- * }; @endcode
- * It would be used with the boost::asio::connect function as follows:
- * @code tcp::resolver r(io_service);
- * tcp::resolver::query q("host", "service");
- * tcp::socket s(io_service);
- *
- * // ...
- *
- * r.async_resolve(q, resolve_handler);
- *
- * // ...
- *
- * void resolve_handler(
- *     const boost::system::error_code& ec,
- *     tcp::resolver::iterator i)
- * {
- *   if (!ec)
- *   {
- *     boost::asio::async_connect(s, i,
- *         my_connect_condition(),
- *         connect_handler);
- *   }
- * }
- *
- * // ...
- *
- * void connect_handler(
- *     const boost::system::error_code& ec,
- *     tcp::resolver::iterator i)
- * {
- *   if (ec)
- *   {
- *     // An error occurred.
- *   }
- *   else
- *   {
- *     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,
-    ConnectCondition connect_condition,
-    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
- * endpoints. It does this by repeated calls to the socket's @c async_connect
- * member function, once for each endpoint in the sequence, until a connection
- * is successfully established.
- *
- * @param s The socket to be connected. If the socket is already open, it will
- * be closed.
- *
- * @param begin An iterator pointing to the start of a sequence of endpoints.
- *
- * @param end An iterator pointing to the end of a sequence of endpoints.
- *
- * @param connect_condition A function object that is called prior to each
- * connection attempt. The signature of the function object must be:
- * @code Iterator connect_condition(
- *     const boost::system::error_code& ec,
- *     Iterator next); @endcode
- * The @c ec parameter contains the result from the most recent connect
- * operation. Before the first connection attempt, @c ec is always set to
- * indicate success. The @c next parameter is an iterator pointing to the next
- * endpoint to be tried. The function object should return the next iterator,
- * but is permitted to return a different iterator so that endpoints may be
- * skipped. The implementation guarantees that the function object will never
- * be called with the end iterator.
- *
- * @param handler The handler to be called when the connect operation
- * completes. Copies will be made of the handler as required. The function
- * signature of the handler must be:
- * @code void handler(
- *   // Result of operation. if the sequence is empty, set to
- *   // boost::asio::error::not_found. Otherwise, contains the
- *   // error from the last connection attempt.
- *   const boost::system::error_code& error,
- *
- *   // On success, an iterator denoting the successfully
- *   // connected endpoint. Otherwise, the end iterator.
- *   Iterator iterator
- * ); @endcode
- * 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().
- *
- * @par Example
- * The following connect condition function object can be used to output
- * information about the individual connection attempts:
- * @code struct my_connect_condition
- * {
- *   template <typename Iterator>
- *   Iterator operator()(
- *       const boost::system::error_code& ec,
- *       Iterator next)
- *   {
- *     if (ec) std::cout << "Error: " << ec.message() << std::endl;
- *     std::cout << "Trying: " << next->endpoint() << std::endl;
- *     return next;
- *   }
- * }; @endcode
- * It would be used with the boost::asio::connect function as follows:
- * @code tcp::resolver r(io_service);
- * tcp::resolver::query q("host", "service");
- * tcp::socket s(io_service);
- *
- * // ...
- *
- * r.async_resolve(q, resolve_handler);
- *
- * // ...
- *
- * void resolve_handler(
- *     const boost::system::error_code& ec,
- *     tcp::resolver::iterator i)
- * {
- *   if (!ec)
- *   {
- *     tcp::resolver::iterator end;
- *     boost::asio::async_connect(s, i, end,
- *         my_connect_condition(),
- *         connect_handler);
- *   }
- * }
- *
- * // ...
- *
- * void connect_handler(
- *     const boost::system::error_code& ec,
- *     tcp::resolver::iterator i)
- * {
- *   if (ec)
- *   {
- *     // An error occurred.
- *   }
- *   else
- *   {
- *     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, Iterator end, ConnectCondition connect_condition,
-    BOOST_ASIO_MOVE_ARG(ComposedConnectHandler) handler);
-
-/*@}*/
-
-} // namespace asio
-} // namespace boost
-
-#include <boost/asio/detail/pop_options.hpp>
-
-#include <boost/asio/impl/connect.hpp>
-
-#endif
diff --git a/3rdParty/Boost/src/boost/asio/datagram_socket_service.hpp b/3rdParty/Boost/src/boost/asio/datagram_socket_service.hpp
index 6e60a4f..0db1f34 100644
--- a/3rdParty/Boost/src/boost/asio/datagram_socket_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/datagram_socket_service.hpp
@@ -1,378 +1,313 @@
 //
 // datagram_socket_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_DATAGRAM_SOCKET_SERVICE_HPP
 #define BOOST_ASIO_DATAGRAM_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>
 #include <cstddef>
 #include <boost/asio/error.hpp>
 #include <boost/asio/io_service.hpp>
 
 #if 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>
 
 namespace boost {
 namespace asio {
 
 /// Default service implementation for a datagram socket.
 template <typename Protocol>
 class datagram_socket_service
 #if defined(GENERATING_DOCUMENTATION)
   : public boost::asio::io_service::service
 #else
   : public boost::asio::detail::service_base<datagram_socket_service<Protocol> >
 #endif
 {
 public:
 #if defined(GENERATING_DOCUMENTATION)
   /// The unique service identifier.
   static boost::asio::io_service::id id;
 #endif
 
   /// The protocol type.
   typedef Protocol protocol_type;
 
   /// The endpoint type.
   typedef typename Protocol::endpoint endpoint_type;
 
 private:
   // The type of the platform-specific implementation.
 #if 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:
   /// The type of a datagram socket.
 #if defined(GENERATING_DOCUMENTATION)
   typedef implementation_defined implementation_type;
 #else
   typedef typename service_impl_type::implementation_type implementation_type;
 #endif
 
-  /// (Deprecated: Use native_handle_type.) The native socket type.
-#if defined(GENERATING_DOCUMENTATION)
-  typedef implementation_defined native_type;
-#else
-  typedef typename service_impl_type::native_handle_type native_type;
-#endif
-
   /// The native socket type.
 #if defined(GENERATING_DOCUMENTATION)
-  typedef implementation_defined native_handle_type;
+  typedef implementation_defined native_type;
 #else
-  typedef typename service_impl_type::native_handle_type native_handle_type;
+  typedef typename service_impl_type::native_type native_type;
 #endif
 
   /// Construct a new datagram socket service for the specified io_service.
   explicit datagram_socket_service(boost::asio::io_service& io_service)
     : boost::asio::detail::service_base<
         datagram_socket_service<Protocol> >(io_service),
       service_impl_(io_service)
   {
   }
 
-  /// Construct a new datagram socket implementation.
-  void construct(implementation_type& impl)
-  {
-    service_impl_.construct(impl);
-  }
-
-#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
-  /// Move-construct a new datagram socket implementation.
-  void move_construct(implementation_type& impl,
-      implementation_type& other_impl)
+  /// Destroy all user-defined handler objects owned by the service.
+  void shutdown_service()
   {
-    service_impl_.move_construct(impl, other_impl);
+    service_impl_.shutdown_service();
   }
 
-  /// Move-assign from another datagram socket implementation.
-  void move_assign(implementation_type& impl,
-      datagram_socket_service& other_service,
-      implementation_type& other_impl)
+  /// Construct a new datagram socket implementation.
+  void construct(implementation_type& impl)
   {
-    service_impl_.move_assign(impl, other_service.service_impl_, other_impl);
+    service_impl_.construct(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)
       service_impl_.open(impl, protocol, ec);
     else
       ec = boost::asio::error::invalid_argument;
     return ec;
   }
 
   /// Assign an existing native socket to a datagram socket.
   boost::system::error_code assign(implementation_type& impl,
-      const protocol_type& protocol, const native_handle_type& native_socket,
+      const protocol_type& protocol, const native_type& native_socket,
       boost::system::error_code& ec)
   {
     return service_impl_.assign(impl, protocol, native_socket, ec);
   }
 
   /// Determine whether the socket is open.
   bool is_open(const implementation_type& impl) const
   {
     return service_impl_.is_open(impl);
   }
 
   /// Close a datagram socket implementation.
   boost::system::error_code close(implementation_type& impl,
       boost::system::error_code& ec)
   {
     return service_impl_.close(impl, ec);
   }
 
-  /// (Deprecated: Use native_handle().) Get the native socket implementation.
-  native_type native(implementation_type& impl)
-  {
-    return service_impl_.native_handle(impl);
-  }
-
   /// Get the native socket implementation.
-  native_handle_type native_handle(implementation_type& impl)
+  native_type native(implementation_type& impl)
   {
-    return service_impl_.native_handle(impl);
+    return service_impl_.native(impl);
   }
 
   /// Cancel all asynchronous operations associated with the socket.
   boost::system::error_code cancel(implementation_type& impl,
       boost::system::error_code& ec)
   {
     return service_impl_.cancel(impl, ec);
   }
 
   /// Determine whether the socket is at the out-of-band data mark.
   bool at_mark(const implementation_type& impl,
       boost::system::error_code& ec) const
   {
     return service_impl_.at_mark(impl, ec);
   }
 
   /// Determine the number of bytes available for reading.
   std::size_t available(const implementation_type& impl,
       boost::system::error_code& ec) const
   {
     return service_impl_.available(impl, ec);
   }
 
   // Bind the datagram socket to the specified local endpoint.
   boost::system::error_code bind(implementation_type& impl,
       const endpoint_type& endpoint, boost::system::error_code& ec)
   {
     return service_impl_.bind(impl, endpoint, ec);
   }
 
   /// Connect the datagram socket to the specified endpoint.
   boost::system::error_code connect(implementation_type& impl,
       const endpoint_type& peer_endpoint, boost::system::error_code& ec)
   {
     return service_impl_.connect(impl, peer_endpoint, ec);
   }
 
   /// Start an asynchronous connect.
   template <typename ConnectHandler>
   void async_connect(implementation_type& impl,
-      const endpoint_type& peer_endpoint,
-      BOOST_ASIO_MOVE_ARG(ConnectHandler) handler)
+      const endpoint_type& peer_endpoint, ConnectHandler handler)
   {
-    service_impl_.async_connect(impl, peer_endpoint,
-        BOOST_ASIO_MOVE_CAST(ConnectHandler)(handler));
+    service_impl_.async_connect(impl, peer_endpoint, handler);
   }
 
   /// Set a socket option.
   template <typename SettableSocketOption>
   boost::system::error_code set_option(implementation_type& impl,
       const SettableSocketOption& option, boost::system::error_code& ec)
   {
     return service_impl_.set_option(impl, option, ec);
   }
 
   /// Get a socket option.
   template <typename GettableSocketOption>
   boost::system::error_code get_option(const implementation_type& impl,
       GettableSocketOption& option, boost::system::error_code& ec) const
   {
     return service_impl_.get_option(impl, option, ec);
   }
 
   /// Perform an IO control command on the socket.
   template <typename IoControlCommand>
   boost::system::error_code io_control(implementation_type& impl,
       IoControlCommand& command, boost::system::error_code& ec)
   {
     return service_impl_.io_control(impl, command, ec);
   }
 
-  /// Gets the non-blocking mode of the socket.
-  bool non_blocking(const implementation_type& impl) const
-  {
-    return service_impl_.non_blocking(impl);
-  }
-
-  /// Sets the non-blocking mode of the socket.
-  boost::system::error_code non_blocking(implementation_type& impl,
-      bool mode, boost::system::error_code& ec)
-  {
-    return service_impl_.non_blocking(impl, mode, ec);
-  }
-
-  /// Gets the non-blocking mode of the native socket implementation.
-  bool native_non_blocking(const implementation_type& impl) const
-  {
-    return service_impl_.native_non_blocking(impl);
-  }
-
-  /// Sets the non-blocking mode of the native socket implementation.
-  boost::system::error_code native_non_blocking(implementation_type& impl,
-      bool mode, boost::system::error_code& ec)
-  {
-    return service_impl_.native_non_blocking(impl, mode, ec);
-  }
-
   /// Get the local endpoint.
   endpoint_type local_endpoint(const implementation_type& impl,
       boost::system::error_code& ec) const
   {
     return service_impl_.local_endpoint(impl, ec);
   }
 
   /// Get the remote endpoint.
   endpoint_type remote_endpoint(const implementation_type& impl,
       boost::system::error_code& ec) const
   {
     return service_impl_.remote_endpoint(impl, ec);
   }
 
   /// Disable sends or receives on the socket.
   boost::system::error_code shutdown(implementation_type& impl,
       socket_base::shutdown_type what, boost::system::error_code& ec)
   {
     return service_impl_.shutdown(impl, what, ec);
   }
 
   /// Send the given data to the peer.
   template <typename ConstBufferSequence>
   std::size_t send(implementation_type& impl,
       const ConstBufferSequence& buffers,
       socket_base::message_flags flags, boost::system::error_code& ec)
   {
     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,
-      socket_base::message_flags flags,
-      BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
+      socket_base::message_flags flags, WriteHandler handler)
   {
-    service_impl_.async_send(impl, buffers, flags,
-        BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
+    service_impl_.async_send(impl, buffers, flags, handler);
   }
 
   /// 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,
       socket_base::message_flags flags, boost::system::error_code& ec)
   {
     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,
       const ConstBufferSequence& buffers, const endpoint_type& destination,
-      socket_base::message_flags flags,
-      BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
+      socket_base::message_flags flags, WriteHandler handler)
   {
-    service_impl_.async_send_to(impl, buffers, destination, flags,
-        BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
+    service_impl_.async_send_to(impl, buffers, destination, flags, handler);
   }
 
   /// Receive some data from the peer.
   template <typename MutableBufferSequence>
   std::size_t receive(implementation_type& impl,
       const MutableBufferSequence& buffers,
       socket_base::message_flags flags, boost::system::error_code& ec)
   {
     return service_impl_.receive(impl, buffers, flags, ec);
   }
 
   /// Start an asynchronous receive.
   template <typename MutableBufferSequence, typename ReadHandler>
   void async_receive(implementation_type& impl,
       const MutableBufferSequence& buffers,
-      socket_base::message_flags flags,
-      BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+      socket_base::message_flags flags, ReadHandler handler)
   {
-    service_impl_.async_receive(impl, buffers, flags,
-        BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
+    service_impl_.async_receive(impl, buffers, flags, handler);
   }
 
   /// 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,
       socket_base::message_flags flags, boost::system::error_code& ec)
   {
     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,
       const MutableBufferSequence& buffers, endpoint_type& sender_endpoint,
-      socket_base::message_flags flags,
-      BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+      socket_base::message_flags flags, ReadHandler handler)
   {
     service_impl_.async_receive_from(impl, buffers, sender_endpoint, flags,
-        BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
+        handler);
   }
 
 private:
-  // Destroy all user-defined handler objects owned by the service.
-  void shutdown_service()
-  {
-    service_impl_.shutdown_service();
-  }
-
   // The platform-specific implementation.
   service_impl_type service_impl_;
 };
 
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // BOOST_ASIO_DATAGRAM_SOCKET_SERVICE_HPP
diff --git a/3rdParty/Boost/src/boost/asio/deadline_timer.hpp b/3rdParty/Boost/src/boost/asio/deadline_timer.hpp
index 82e65a7..866588b 100644
--- a/3rdParty/Boost/src/boost/asio/deadline_timer.hpp
+++ b/3rdParty/Boost/src/boost/asio/deadline_timer.hpp
@@ -1,35 +1,35 @@
 //
 // deadline_timer.hpp
 // ~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_DEADLINE_TIMER_HPP
 #define BOOST_ASIO_DEADLINE_TIMER_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/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>
 
 namespace boost {
 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 // 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..ce8fd13 100644
--- a/3rdParty/Boost/src/boost/asio/deadline_timer_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/deadline_timer_service.hpp
@@ -1,157 +1,148 @@
 //
 // deadline_timer_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_DEADLINE_TIMER_SERVICE_HPP
 #define BOOST_ASIO_DEADLINE_TIMER_SERVICE_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/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>
 
 namespace boost {
 namespace asio {
 
 /// Default service implementation for a timer.
 template <typename TimeType,
     typename TimeTraits = boost::asio::time_traits<TimeType> >
 class deadline_timer_service
 #if defined(GENERATING_DOCUMENTATION)
   : public boost::asio::io_service::service
 #else
   : public boost::asio::detail::service_base<
       deadline_timer_service<TimeType, TimeTraits> >
 #endif
 {
 public:
 #if defined(GENERATING_DOCUMENTATION)
   /// The unique service identifier.
   static boost::asio::io_service::id id;
 #endif
 
   /// The time traits type.
   typedef TimeTraits traits_type;
 
   /// The time type.
   typedef typename traits_type::time_type time_type;
 
   /// The duration type.
   typedef typename traits_type::duration_type duration_type;
 
 private:
   // The type of the platform-specific implementation.
   typedef detail::deadline_timer_service<traits_type> service_impl_type;
 
 public:
   /// The implementation type of the deadline timer.
 #if defined(GENERATING_DOCUMENTATION)
   typedef implementation_defined implementation_type;
 #else
   typedef typename service_impl_type::implementation_type implementation_type;
 #endif
 
   /// Construct a new timer service for the specified io_service.
   explicit deadline_timer_service(boost::asio::io_service& io_service)
     : boost::asio::detail::service_base<
         deadline_timer_service<TimeType, TimeTraits> >(io_service),
       service_impl_(io_service)
   {
   }
 
+  /// Destroy all user-defined handler objects owned by the service.
+  void shutdown_service()
+  {
+    service_impl_.shutdown_service();
+  }
+
   /// Construct a new timer implementation.
   void construct(implementation_type& impl)
   {
     service_impl_.construct(impl);
   }
 
   /// Destroy a timer implementation.
   void destroy(implementation_type& impl)
   {
     service_impl_.destroy(impl);
   }
 
   /// Cancel any asynchronous wait operations associated with the timer.
   std::size_t cancel(implementation_type& impl, boost::system::error_code& ec)
   {
     return service_impl_.cancel(impl, ec);
   }
 
-  /// Cancels one asynchronous wait operation associated with the timer.
-  std::size_t cancel_one(implementation_type& impl,
-      boost::system::error_code& ec)
-  {
-    return service_impl_.cancel_one(impl, ec);
-  }
-
   /// Get the expiry time for the timer as an absolute time.
   time_type expires_at(const implementation_type& impl) const
   {
     return service_impl_.expires_at(impl);
   }
 
   /// Set the expiry time for the timer as an absolute time.
   std::size_t expires_at(implementation_type& impl,
       const time_type& expiry_time, boost::system::error_code& ec)
   {
     return service_impl_.expires_at(impl, expiry_time, ec);
   }
 
   /// Get the expiry time for the timer relative to now.
   duration_type expires_from_now(const implementation_type& impl) const
   {
     return service_impl_.expires_from_now(impl);
   }
 
   /// Set the expiry time for the timer relative to now.
   std::size_t expires_from_now(implementation_type& impl,
       const duration_type& expiry_time, boost::system::error_code& ec)
   {
     return service_impl_.expires_from_now(impl, expiry_time, ec);
   }
 
   // Perform a blocking wait on the timer.
   void wait(implementation_type& impl, boost::system::error_code& ec)
   {
     service_impl_.wait(impl, ec);
   }
 
   // Start an asynchronous wait on the timer.
   template <typename WaitHandler>
-  void async_wait(implementation_type& impl,
-      BOOST_ASIO_MOVE_ARG(WaitHandler) handler)
+  void async_wait(implementation_type& impl, WaitHandler handler)
   {
-    service_impl_.async_wait(impl, BOOST_ASIO_MOVE_CAST(WaitHandler)(handler));
+    service_impl_.async_wait(impl, handler);
   }
 
 private:
-  // Destroy all user-defined handler objects owned by the service.
-  void shutdown_service()
-  {
-    service_impl_.shutdown_service();
-  }
-
   // The platform-specific implementation.
   service_impl_type service_impl_;
 };
 
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // BOOST_ASIO_DEADLINE_TIMER_SERVICE_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/array.hpp b/3rdParty/Boost/src/boost/asio/detail/array.hpp
deleted file mode 100644
index be141b1..0000000
--- a/3rdParty/Boost/src/boost/asio/detail/array.hpp
+++ /dev/null
@@ -1,40 +0,0 @@
-//
-// detail/array.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_ARRAY_HPP
-#define BOOST_ASIO_DETAIL_ARRAY_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_ARRAY)
-# include <array>
-#else // defined(BOOST_ASIO_HAS_STD_ARRAY)
-# include <boost/array.hpp>
-#endif // defined(BOOST_ASIO_HAS_STD_ARRAY)
-
-namespace boost {
-namespace asio {
-namespace detail {
-
-#if defined(BOOST_ASIO_HAS_STD_ARRAY)
-using std::array;
-#else // defined(BOOST_ASIO_HAS_STD_ARRAY)
-using boost::array;
-#endif // defined(BOOST_ASIO_HAS_STD_ARRAY)
-
-} // namespace detail
-} // namespace asio
-} // namespace boost
-
-#endif // 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..b7a27bf 100644
--- a/3rdParty/Boost/src/boost/asio/detail/array_fwd.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/array_fwd.hpp
@@ -1,34 +1,25 @@
 //
 // detail/array_fwd.hpp
 // ~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_ARRAY_FWD_HPP
 #define BOOST_ASIO_DETAIL_ARRAY_FWD_HPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
-#include <boost/asio/detail/config.hpp>
-
 namespace boost {
 
 template<class T, std::size_t N>
 class array;
 
 } // namespace boost
 
-// Standard library components can't be forward declared, so we'll have to
-// include the array header. Fortunately, it's fairly lightweight and doesn't
-// add significantly to the compile time.
-#if defined(BOOST_ASIO_HAS_STD_ARRAY)
-# include <array>
-#endif // defined(BOOST_ASIO_HAS_STD_ARRAY)
-
 #endif // BOOST_ASIO_DETAIL_ARRAY_FWD_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/atomic_count.hpp b/3rdParty/Boost/src/boost/asio/detail/atomic_count.hpp
deleted file mode 100644
index 5e0051a..0000000
--- a/3rdParty/Boost/src/boost/asio/detail/atomic_count.hpp
+++ /dev/null
@@ -1,47 +0,0 @@
-//
-// detail/atomic_count.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_ATOMIC_COUNT_HPP
-#define BOOST_ASIO_DETAIL_ATOMIC_COUNT_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_HAS_THREADS) || defined(BOOST_ASIO_DISABLE_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)
-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)
-typedef boost::detail::atomic_count atomic_count;
-inline void increment(atomic_count& a, long b) { while (b > 0) ++a, --b; }
-#endif // defined(BOOST_ASIO_HAS_STD_ATOMIC)
-
-} // namespace detail
-} // namespace asio
-} // namespace boost
-
-#endif // BOOST_ASIO_DETAIL_ATOMIC_COUNT_HPP
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..b2b76d6 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,40 +1,40 @@
 //
 // detail/base_from_completion_cond.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_BASE_FROM_COMPLETION_COND_HPP
 #define BOOST_ASIO_DETAIL_BASE_FROM_COMPLETION_COND_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/completion_condition.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 template <typename CompletionCondition>
 class base_from_completion_cond
 {
 protected:
   explicit base_from_completion_cond(CompletionCondition completion_condition)
     : completion_condition_(completion_condition)
   {
   }
 
   std::size_t check_for_completion(
       const boost::system::error_code& ec,
       std::size_t total_transferred)
   {
     return detail::adapt_completion_condition_result(
diff --git a/3rdParty/Boost/src/boost/asio/detail/bind_handler.hpp b/3rdParty/Boost/src/boost/asio/detail/bind_handler.hpp
index 0bd7e53..0199643 100644
--- a/3rdParty/Boost/src/boost/asio/detail/bind_handler.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/bind_handler.hpp
@@ -1,448 +1,362 @@
 //
 // detail/bind_handler.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_BIND_HANDLER_HPP
 #define BOOST_ASIO_DETAIL_BIND_HANDLER_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/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, typename Arg1>
 class binder1
 {
 public:
   binder1(const Handler& handler, const Arg1& arg1)
     : handler_(handler),
       arg1_(arg1)
   {
   }
 
-  binder1(Handler& handler, const Arg1& arg1)
-    : handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)),
-      arg1_(arg1)
-  {
-  }
-
   void operator()()
   {
     handler_(static_cast<const Arg1&>(arg1_));
   }
 
   void operator()() const
   {
     handler_(arg1_);
   }
 
 //private:
   Handler handler_;
   Arg1 arg1_;
 };
 
 template <typename Handler, typename Arg1>
 inline void* asio_handler_allocate(std::size_t size,
     binder1<Handler, Arg1>* this_handler)
 {
   return boost_asio_handler_alloc_helpers::allocate(
       size, this_handler->handler_);
 }
 
 template <typename Handler, typename Arg1>
 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 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_);
-}
-
-template <typename Function, typename Handler, typename Arg1>
 inline void asio_handler_invoke(const Function& function,
     binder1<Handler, Arg1>* this_handler)
 {
   boost_asio_handler_invoke_helpers::invoke(
       function, this_handler->handler_);
 }
 
 template <typename Handler, typename Arg1>
-inline binder1<Handler, Arg1> bind_handler(Handler handler,
+inline binder1<Handler, Arg1> bind_handler(const Handler& handler,
     const Arg1& arg1)
 {
   return binder1<Handler, Arg1>(handler, arg1);
 }
 
 template <typename Handler, typename Arg1, typename Arg2>
 class binder2
 {
 public:
   binder2(const Handler& handler, const Arg1& arg1, const Arg2& arg2)
     : handler_(handler),
       arg1_(arg1),
       arg2_(arg2)
   {
   }
 
-  binder2(Handler& handler, const Arg1& arg1, const Arg2& arg2)
-    : handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)),
-      arg1_(arg1),
-      arg2_(arg2)
-  {
-  }
-
   void operator()()
   {
     handler_(static_cast<const Arg1&>(arg1_),
         static_cast<const Arg2&>(arg2_));
   }
 
   void operator()() const
   {
     handler_(arg1_, arg2_);
   }
 
 //private:
   Handler handler_;
   Arg1 arg1_;
   Arg2 arg2_;
 };
 
 template <typename Handler, typename Arg1, typename Arg2>
 inline void* asio_handler_allocate(std::size_t size,
     binder2<Handler, Arg1, Arg2>* this_handler)
 {
   return boost_asio_handler_alloc_helpers::allocate(
       size, this_handler->handler_);
 }
 
 template <typename Handler, typename Arg1, typename Arg2>
 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 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_);
-}
-
-template <typename Function, typename Handler, typename Arg1, typename Arg2>
 inline void asio_handler_invoke(const Function& function,
     binder2<Handler, Arg1, Arg2>* this_handler)
 {
   boost_asio_handler_invoke_helpers::invoke(
       function, this_handler->handler_);
 }
 
 template <typename Handler, typename Arg1, typename Arg2>
-inline binder2<Handler, Arg1, Arg2> bind_handler(Handler handler,
+inline binder2<Handler, Arg1, Arg2> bind_handler(const Handler& handler,
     const Arg1& arg1, const Arg2& arg2)
 {
   return binder2<Handler, Arg1, Arg2>(handler, arg1, arg2);
 }
 
 template <typename Handler, typename Arg1, typename Arg2, typename Arg3>
 class binder3
 {
 public:
   binder3(const Handler& handler, const Arg1& arg1, const Arg2& arg2,
       const Arg3& arg3)
     : handler_(handler),
       arg1_(arg1),
       arg2_(arg2),
       arg3_(arg3)
   {
   }
 
-  binder3(Handler& handler, const Arg1& arg1, const Arg2& arg2,
-      const Arg3& arg3)
-    : handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)),
-      arg1_(arg1),
-      arg2_(arg2),
-      arg3_(arg3)
-  {
-  }
-
   void operator()()
   {
     handler_(static_cast<const Arg1&>(arg1_),
         static_cast<const Arg2&>(arg2_),
         static_cast<const Arg3&>(arg3_));
   }
 
   void operator()() const
   {
     handler_(arg1_, arg2_, arg3_);
   }
 
 //private:
   Handler handler_;
   Arg1 arg1_;
   Arg2 arg2_;
   Arg3 arg3_;
 };
 
 template <typename Handler, typename Arg1, typename Arg2, typename Arg3>
 inline void* asio_handler_allocate(std::size_t size,
     binder3<Handler, Arg1, Arg2, Arg3>* this_handler)
 {
   return boost_asio_handler_alloc_helpers::allocate(
       size, this_handler->handler_);
 }
 
 template <typename Handler, typename Arg1, typename Arg2, typename Arg3>
 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 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(
-      function, this_handler->handler_);
-}
-
-template <typename Function, typename Handler, typename Arg1, typename Arg2,
-    typename Arg3>
 inline void asio_handler_invoke(const Function& function,
     binder3<Handler, Arg1, Arg2, Arg3>* this_handler)
 {
   boost_asio_handler_invoke_helpers::invoke(
       function, this_handler->handler_);
 }
 
 template <typename Handler, typename Arg1, typename Arg2, typename Arg3>
-inline binder3<Handler, Arg1, Arg2, Arg3> bind_handler(Handler handler,
+inline binder3<Handler, Arg1, Arg2, Arg3> bind_handler(const Handler& handler,
     const Arg1& arg1, const Arg2& arg2, const Arg3& arg3)
 {
   return binder3<Handler, Arg1, Arg2, Arg3>(handler, arg1, arg2, arg3);
 }
 
 template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
     typename Arg4>
 class binder4
 {
 public:
   binder4(const Handler& handler, const Arg1& arg1, const Arg2& arg2,
       const Arg3& arg3, const Arg4& arg4)
     : handler_(handler),
       arg1_(arg1),
       arg2_(arg2),
       arg3_(arg3),
       arg4_(arg4)
   {
   }
 
-  binder4(Handler& handler, const Arg1& arg1, const Arg2& arg2,
-      const Arg3& arg3, const Arg4& arg4)
-    : handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)),
-      arg1_(arg1),
-      arg2_(arg2),
-      arg3_(arg3),
-      arg4_(arg4)
-  {
-  }
-
   void operator()()
   {
     handler_(static_cast<const Arg1&>(arg1_),
         static_cast<const Arg2&>(arg2_),
         static_cast<const Arg3&>(arg3_),
         static_cast<const Arg4&>(arg4_));
   }
 
   void operator()() const
   {
     handler_(arg1_, arg2_, arg3_, arg4_);
   }
 
 //private:
   Handler handler_;
   Arg1 arg1_;
   Arg2 arg2_;
   Arg3 arg3_;
   Arg4 arg4_;
 };
 
 template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
     typename Arg4>
 inline void* asio_handler_allocate(std::size_t size,
     binder4<Handler, Arg1, Arg2, Arg3, Arg4>* this_handler)
 {
   return boost_asio_handler_alloc_helpers::allocate(
       size, this_handler->handler_);
 }
 
 template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
     typename Arg4>
 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 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(
-      function, this_handler->handler_);
-}
-
-template <typename Function, typename Handler, typename Arg1, typename Arg2,
-    typename Arg3, typename Arg4>
 inline void asio_handler_invoke(const Function& function,
     binder4<Handler, Arg1, Arg2, Arg3, Arg4>* this_handler)
 {
   boost_asio_handler_invoke_helpers::invoke(
       function, this_handler->handler_);
 }
 
 template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
     typename Arg4>
 inline binder4<Handler, Arg1, Arg2, Arg3, Arg4> bind_handler(
-    Handler handler, const Arg1& arg1, const Arg2& arg2,
+    const Handler& handler, const Arg1& arg1, const Arg2& arg2,
     const Arg3& arg3, const Arg4& arg4)
 {
   return binder4<Handler, Arg1, Arg2, Arg3, Arg4>(handler, arg1, arg2, arg3,
       arg4);
 }
 
 template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
     typename Arg4, typename Arg5>
 class binder5
 {
 public:
   binder5(const Handler& handler, const Arg1& arg1, const Arg2& arg2,
       const Arg3& arg3, const Arg4& arg4, const Arg5& arg5)
     : handler_(handler),
       arg1_(arg1),
       arg2_(arg2),
       arg3_(arg3),
       arg4_(arg4),
       arg5_(arg5)
   {
   }
 
-  binder5(Handler& handler, const Arg1& arg1, const Arg2& arg2,
-      const Arg3& arg3, const Arg4& arg4, const Arg5& arg5)
-    : handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)),
-      arg1_(arg1),
-      arg2_(arg2),
-      arg3_(arg3),
-      arg4_(arg4),
-      arg5_(arg5)
-  {
-  }
-
   void operator()()
   {
     handler_(static_cast<const Arg1&>(arg1_),
         static_cast<const Arg2&>(arg2_),
         static_cast<const Arg3&>(arg3_),
         static_cast<const Arg4&>(arg4_),
         static_cast<const Arg5&>(arg5_));
   }
 
   void operator()() const
   {
     handler_(arg1_, arg2_, arg3_, arg4_, arg5_);
   }
 
 //private:
   Handler handler_;
   Arg1 arg1_;
   Arg2 arg2_;
   Arg3 arg3_;
   Arg4 arg4_;
   Arg5 arg5_;
 };
 
 template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
     typename Arg4, typename Arg5>
 inline void* asio_handler_allocate(std::size_t size,
     binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>* this_handler)
 {
   return boost_asio_handler_alloc_helpers::allocate(
       size, this_handler->handler_);
 }
 
 template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
     typename Arg4, typename Arg5>
 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 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(
-      function, this_handler->handler_);
-}
-
-template <typename Function, typename Handler, typename Arg1, typename Arg2,
-    typename Arg3, typename Arg4, typename Arg5>
 inline void asio_handler_invoke(const Function& function,
     binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>* this_handler)
 {
   boost_asio_handler_invoke_helpers::invoke(
       function, this_handler->handler_);
 }
 
 template <typename Handler, typename Arg1, typename Arg2, typename Arg3,
     typename Arg4, typename Arg5>
 inline binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5> bind_handler(
-    Handler handler, const Arg1& arg1, const Arg2& arg2,
+    const Handler& handler, const Arg1& arg1, const Arg2& arg2,
     const Arg3& arg3, const Arg4& arg4, const Arg5& arg5)
 {
   return binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>(handler, arg1, arg2,
       arg3, arg4, arg5);
 }
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // BOOST_ASIO_DETAIL_BIND_HANDLER_HPP
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..7df4128 100644
--- a/3rdParty/Boost/src/boost/asio/detail/buffer_resize_guard.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/buffer_resize_guard.hpp
@@ -1,40 +1,40 @@
 //
 // detail/buffer_resize_guard.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_BUFFER_RESIZE_GUARD_HPP
 #define BOOST_ASIO_DETAIL_BUFFER_RESIZE_GUARD_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/limits.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 // Helper class to manage buffer resizing in an exception safe way.
 template <typename Buffer>
 class buffer_resize_guard
 {
 public:
   // Constructor.
   buffer_resize_guard(Buffer& buffer)
     : buffer_(buffer),
       old_size_(buffer.size())
   {
   }
 
   // Destructor rolls back the buffer resize unless commit was called.
   ~buffer_resize_guard()
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..fdda23f 100644
--- a/3rdParty/Boost/src/boost/asio/detail/buffer_sequence_adapter.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/buffer_sequence_adapter.hpp
@@ -1,365 +1,256 @@
 //
 // detail/buffer_sequence_adapter.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_BUFFER_SEQUENCE_ADAPTER_HPP
 #define BOOST_ASIO_DETAIL_BUFFER_SEQUENCE_ADAPTER_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/buffer.hpp>
-#include <boost/asio/detail/array_fwd.hpp>
 #include <boost/asio/detail/socket_types.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 class buffer_sequence_adapter_base
 {
 protected:
 #if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
   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);
     buf.len = static_cast<ULONG>(boost::asio::buffer_size(buffer));
   }
 
   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__)
   typedef iovec native_buffer_type;
 
   static void init_iov_base(void*& base, void* addr)
   {
     base = addr;
   }
 
   template <typename T>
   static void init_iov_base(T& base, void* addr)
   {
     base = static_cast<T>(addr);
   }
 
   static void init_native_buffer(iovec& iov,
       const boost::asio::mutable_buffer& buffer)
   {
     init_iov_base(iov.iov_base, boost::asio::buffer_cast<void*>(buffer));
     iov.iov_len = boost::asio::buffer_size(buffer);
   }
 
   static void init_native_buffer(iovec& iov,
       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__)
 };
 
 // Helper class to translate buffers into the native buffer representation.
 template <typename Buffer, typename Buffers>
 class buffer_sequence_adapter
   : buffer_sequence_adapter_base
 {
 public:
-  explicit buffer_sequence_adapter(const Buffers& buffer_sequence)
+  explicit buffer_sequence_adapter(const Buffers& buffers)
     : count_(0), total_buffer_size_(0)
   {
-    typename Buffers::const_iterator iter = buffer_sequence.begin();
-    typename Buffers::const_iterator end = buffer_sequence.end();
+    typename Buffers::const_iterator iter = buffers.begin();
+    typename Buffers::const_iterator end = buffers.end();
     for (; iter != end && count_ < max_buffers; ++iter, ++count_)
     {
       Buffer buffer(*iter);
       init_native_buffer(buffers_[count_], buffer);
       total_buffer_size_ += boost::asio::buffer_size(buffer);
     }
   }
 
   native_buffer_type* buffers()
   {
     return buffers_;
   }
 
   std::size_t count() const
   {
     return count_;
   }
 
   bool all_empty() const
   {
     return total_buffer_size_ == 0;
   }
 
-  static bool all_empty(const Buffers& buffer_sequence)
+  static bool all_empty(const Buffers& buffers)
   {
-    typename Buffers::const_iterator iter = buffer_sequence.begin();
-    typename Buffers::const_iterator end = buffer_sequence.end();
+    typename Buffers::const_iterator iter = buffers.begin();
+    typename Buffers::const_iterator end = buffers.end();
     std::size_t i = 0;
     for (; iter != end && i < max_buffers; ++iter, ++i)
       if (boost::asio::buffer_size(Buffer(*iter)) > 0)
         return false;
     return true;
   }
 
-  static void validate(const Buffers& buffer_sequence)
+  static void validate(const Buffers& buffers)
   {
-    typename Buffers::const_iterator iter = buffer_sequence.begin();
-    typename Buffers::const_iterator end = buffer_sequence.end();
+    typename Buffers::const_iterator iter = buffers.begin();
+    typename Buffers::const_iterator end = buffers.end();
     for (; iter != end; ++iter)
     {
       Buffer buffer(*iter);
       boost::asio::buffer_cast<const void*>(buffer);
     }
   }
 
-  static Buffer first(const Buffers& buffer_sequence)
+  static Buffer first(const Buffers& buffers)
   {
-    typename Buffers::const_iterator iter = buffer_sequence.begin();
-    typename Buffers::const_iterator end = buffer_sequence.end();
+    typename Buffers::const_iterator iter = buffers.begin();
+    typename Buffers::const_iterator end = buffers.end();
     for (; iter != end; ++iter)
     {
       Buffer buffer(*iter);
       if (boost::asio::buffer_size(buffer) != 0)
         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>
 class buffer_sequence_adapter<Buffer, boost::asio::mutable_buffers_1>
   : buffer_sequence_adapter_base
 {
 public:
   explicit buffer_sequence_adapter(
-      const boost::asio::mutable_buffers_1& buffer_sequence)
+      const boost::asio::mutable_buffers_1& buffers)
   {
-    init_native_buffer(buffer_, Buffer(buffer_sequence));
-    total_buffer_size_ = boost::asio::buffer_size(buffer_sequence);
+    init_native_buffer(buffer_, Buffer(buffers));
+    total_buffer_size_ = boost::asio::buffer_size(buffers);
   }
 
   native_buffer_type* buffers()
   {
     return &buffer_;
   }
 
   std::size_t count() const
   {
     return 1;
   }
 
   bool all_empty() const
   {
     return total_buffer_size_ == 0;
   }
 
-  static bool all_empty(const boost::asio::mutable_buffers_1& buffer_sequence)
+  static bool all_empty(const boost::asio::mutable_buffers_1& buffers)
   {
-    return boost::asio::buffer_size(buffer_sequence) == 0;
+    return boost::asio::buffer_size(buffers) == 0;
   }
 
-  static void validate(const boost::asio::mutable_buffers_1& buffer_sequence)
+  static void validate(const boost::asio::mutable_buffers_1& buffers)
   {
-    boost::asio::buffer_cast<const void*>(buffer_sequence);
+    boost::asio::buffer_cast<const void*>(buffers);
   }
 
-  static Buffer first(const boost::asio::mutable_buffers_1& buffer_sequence)
+  static Buffer first(const boost::asio::mutable_buffers_1& buffers)
   {
-    return Buffer(buffer_sequence);
+    return Buffer(buffers);
   }
 
 private:
   native_buffer_type buffer_;
   std::size_t total_buffer_size_;
 };
 
 template <typename Buffer>
 class buffer_sequence_adapter<Buffer, boost::asio::const_buffers_1>
   : buffer_sequence_adapter_base
 {
 public:
   explicit buffer_sequence_adapter(
-      const boost::asio::const_buffers_1& buffer_sequence)
+      const boost::asio::const_buffers_1& buffers)
   {
-    init_native_buffer(buffer_, Buffer(buffer_sequence));
-    total_buffer_size_ = boost::asio::buffer_size(buffer_sequence);
+    init_native_buffer(buffer_, Buffer(buffers));
+    total_buffer_size_ = boost::asio::buffer_size(buffers);
   }
 
   native_buffer_type* buffers()
   {
     return &buffer_;
   }
 
   std::size_t count() const
   {
     return 1;
   }
 
   bool all_empty() const
   {
     return total_buffer_size_ == 0;
   }
 
-  static bool all_empty(const boost::asio::const_buffers_1& buffer_sequence)
+  static bool all_empty(const boost::asio::const_buffers_1& buffers)
   {
-    return boost::asio::buffer_size(buffer_sequence) == 0;
+    return boost::asio::buffer_size(buffers) == 0;
   }
 
-  static void validate(const boost::asio::const_buffers_1& buffer_sequence)
+  static void validate(const boost::asio::const_buffers_1& buffers)
   {
-    boost::asio::buffer_cast<const void*>(buffer_sequence);
+    boost::asio::buffer_cast<const void*>(buffers);
   }
 
-  static Buffer first(const boost::asio::const_buffers_1& buffer_sequence)
+  static Buffer first(const boost::asio::const_buffers_1& buffers)
   {
-    return Buffer(buffer_sequence);
+    return Buffer(buffers);
   }
 
 private:
   native_buffer_type buffer_;
   std::size_t total_buffer_size_;
 };
 
-template <typename Buffer, typename Elem>
-class buffer_sequence_adapter<Buffer, boost::array<Elem, 2> >
-  : buffer_sequence_adapter_base
-{
-public:
-  explicit buffer_sequence_adapter(
-      const boost::array<Elem, 2>& buffer_sequence)
-  {
-    init_native_buffer(buffers_[0], Buffer(buffer_sequence[0]));
-    init_native_buffer(buffers_[1], Buffer(buffer_sequence[1]));
-    total_buffer_size_ = boost::asio::buffer_size(buffer_sequence[0])
-      + boost::asio::buffer_size(buffer_sequence[1]);
-  }
-
-  native_buffer_type* buffers()
-  {
-    return buffers_;
-  }
-
-  std::size_t count() const
-  {
-    return 2;
-  }
-
-  bool all_empty() const
-  {
-    return total_buffer_size_ == 0;
-  }
-
-  static bool all_empty(const boost::array<Elem, 2>& buffer_sequence)
-  {
-    return boost::asio::buffer_size(buffer_sequence[0]) == 0
-      && boost::asio::buffer_size(buffer_sequence[1]) == 0;
-  }
-
-  static void validate(const boost::array<Elem, 2>& buffer_sequence)
-  {
-    boost::asio::buffer_cast<const void*>(buffer_sequence[0]);
-    boost::asio::buffer_cast<const void*>(buffer_sequence[1]);
-  }
-
-  static Buffer first(const boost::array<Elem, 2>& buffer_sequence)
-  {
-    return Buffer(boost::asio::buffer_size(buffer_sequence[0]) != 0
-        ? buffer_sequence[0] : buffer_sequence[1]);
-  }
-
-private:
-  native_buffer_type buffers_[2];
-  std::size_t total_buffer_size_;
-};
-
-#if defined(BOOST_ASIO_HAS_STD_ARRAY)
-
-template <typename Buffer, typename Elem>
-class buffer_sequence_adapter<Buffer, std::array<Elem, 2> >
-  : buffer_sequence_adapter_base
-{
-public:
-  explicit buffer_sequence_adapter(
-      const std::array<Elem, 2>& buffer_sequence)
-  {
-    init_native_buffer(buffers_[0], Buffer(buffer_sequence[0]));
-    init_native_buffer(buffers_[1], Buffer(buffer_sequence[1]));
-    total_buffer_size_ = boost::asio::buffer_size(buffer_sequence[0])
-      + boost::asio::buffer_size(buffer_sequence[1]);
-  }
-
-  native_buffer_type* buffers()
-  {
-    return buffers_;
-  }
-
-  std::size_t count() const
-  {
-    return 2;
-  }
-
-  bool all_empty() const
-  {
-    return total_buffer_size_ == 0;
-  }
-
-  static bool all_empty(const std::array<Elem, 2>& buffer_sequence)
-  {
-    return boost::asio::buffer_size(buffer_sequence[0]) == 0
-      && boost::asio::buffer_size(buffer_sequence[1]) == 0;
-  }
-
-  static void validate(const std::array<Elem, 2>& buffer_sequence)
-  {
-    boost::asio::buffer_cast<const void*>(buffer_sequence[0]);
-    boost::asio::buffer_cast<const void*>(buffer_sequence[1]);
-  }
-
-  static Buffer first(const std::array<Elem, 2>& buffer_sequence)
-  {
-    return Buffer(boost::asio::buffer_size(buffer_sequence[0]) != 0
-        ? buffer_sequence[0] : buffer_sequence[1]);
-  }
-
-private:
-  native_buffer_type buffers_[2];
-  std::size_t total_buffer_size_;
-};
-
-#endif // defined(BOOST_ASIO_HAS_STD_ARRAY)
-
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #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..86763b5 100644
--- a/3rdParty/Boost/src/boost/asio/detail/buffered_stream_storage.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/buffered_stream_storage.hpp
@@ -1,128 +1,127 @@
 //
 // detail/buffered_stream_storage.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_BUFFERED_STREAM_STORAGE_HPP
 #define BOOST_ASIO_DETAIL_BUFFERED_STREAM_STORAGE_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/buffer.hpp>
-#include <boost/assert.hpp>
+#include <cassert>
 #include <cstddef>
 #include <cstring>
 #include <vector>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 class buffered_stream_storage
 {
 public:
   // The type of the bytes stored in the buffer.
   typedef unsigned char byte_type;
 
   // The type used for offsets into the buffer.
   typedef std::size_t size_type;
 
   // Constructor.
-  explicit buffered_stream_storage(std::size_t buffer_capacity)
+  explicit buffered_stream_storage(std::size_t capacity)
     : begin_offset_(0),
       end_offset_(0),
-      buffer_(buffer_capacity)
+      buffer_(capacity)
   {
   }
 
   /// Clear the buffer.
   void clear()
   {
     begin_offset_ = 0;
     end_offset_ = 0;
   }
 
   // Return a pointer to the beginning of the unread data.
-  mutable_buffer data()
+  byte_type* data()
   {
-    return boost::asio::buffer(buffer_) + begin_offset_;
+    return &buffer_[0] + begin_offset_;
   }
 
   // Return a pointer to the beginning of the unread data.
-  const_buffer data() const
+  const byte_type* data() const
   {
-    return boost::asio::buffer(buffer_) + begin_offset_;
+    return &buffer_[0] + begin_offset_;
   }
 
   // Is there no unread data in the buffer.
   bool empty() const
   {
     return begin_offset_ == end_offset_;
   }
 
   // Return the amount of unread data the is in the buffer.
   size_type size() const
   {
     return end_offset_ - begin_offset_;
   }
 
   // Resize the buffer to the specified length.
   void resize(size_type length)
   {
-    BOOST_ASSERT(length <= capacity());
+    assert(length <= capacity());
     if (begin_offset_ + length <= capacity())
     {
       end_offset_ = begin_offset_ + length;
     }
     else
     {
       using namespace std; // For memmove.
       memmove(&buffer_[0], &buffer_[0] + begin_offset_, size());
       end_offset_ = length;
       begin_offset_ = 0;
     }
   }
 
   // Return the maximum size for data in the buffer.
   size_type capacity() const
   {
     return buffer_.size();
   }
 
   // Consume multiple bytes from the beginning of the buffer.
   void consume(size_type count)
   {
-    BOOST_ASSERT(begin_offset_ + count <= end_offset_);
+    assert(begin_offset_ + count <= end_offset_);
     begin_offset_ += count;
     if (empty())
       clear();
   }
 
 private:
   // The offset to the beginning of the unread data.
   size_type begin_offset_;
 
   // The offset to the end of the unread data.
   size_type end_offset_;
   
   // The data in the buffer.
   std::vector<byte_type> buffer_;
 };
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // BOOST_ASIO_DETAIL_BUFFERED_STREAM_STORAGE_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/call_stack.hpp b/3rdParty/Boost/src/boost/asio/detail/call_stack.hpp
index db4cd1e..d5f9099 100644
--- a/3rdParty/Boost/src/boost/asio/detail/call_stack.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/call_stack.hpp
@@ -1,120 +1,93 @@
 //
 // detail/call_stack.hpp
 // ~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_CALL_STACK_HPP
 #define BOOST_ASIO_DETAIL_CALL_STACK_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/noncopyable.hpp>
 #include <boost/asio/detail/tss_ptr.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 // Helper class to determine whether or not the current thread is inside an
 // invocation of io_service::run() for a specified io_service object.
-template <typename Key, typename Value = unsigned char>
+template <typename Owner>
 class call_stack
 {
 public:
-  // Context class automatically pushes the key/value pair on to the stack.
+  // Context class automatically pushes an owner on to the stack.
   class context
     : private noncopyable
   {
   public:
-    // Push the key on to the stack.
-    explicit context(Key* k)
-      : key_(k),
-        next_(call_stack<Key, Value>::top_)
+    // Push the owner on to the stack.
+    explicit context(Owner* d)
+      : owner_(d),
+        next_(call_stack<Owner>::top_)
     {
-      value_ = reinterpret_cast<unsigned char*>(this);
-      call_stack<Key, Value>::top_ = this;
+      call_stack<Owner>::top_ = this;
     }
 
-    // Push the key/value pair on to the stack.
-    context(Key* k, Value& v)
-      : key_(k),
-        value_(&v),
-        next_(call_stack<Key, Value>::top_)
-    {
-      call_stack<Key, Value>::top_ = this;
-    }
-
-    // Pop the key/value pair from the stack.
+    // Pop the owner from the stack.
     ~context()
     {
-      call_stack<Key, Value>::top_ = next_;
-    }
-
-    // Find the next context with the same key.
-    Value* next_by_key() const
-    {
-      context* elem = next_;
-      while (elem)
-      {
-        if (elem->key_ == key_)
-          return elem->value_;
-        elem = elem->next_;
-      }
-      return 0;
+      call_stack<Owner>::top_ = next_;
     }
 
   private:
-    friend class call_stack<Key, Value>;
-
-    // The key associated with the context.
-    Key* key_;
+    friend class call_stack<Owner>;
 
-    // The value associated with the context.
-    Value* value_;
+    // The owner associated with the context.
+    Owner* owner_;
 
     // The next element in the stack.
     context* next_;
   };
 
   friend class context;
 
-  // Determine whether the specified owner is on the stack. Returns address of
-  // key if present, 0 otherwise.
-  static Value* contains(Key* k)
+  // Determine whether the specified owner is on the stack.
+  static bool contains(Owner* d)
   {
     context* elem = top_;
     while (elem)
     {
-      if (elem->key_ == k)
-        return elem->value_;
+      if (elem->owner_ == d)
+        return true;
       elem = elem->next_;
     }
-    return 0;
+    return false;
   }
 
 private:
   // The top of the stack of calls for the current thread.
   static tss_ptr<context> top_;
 };
 
-template <typename Key, typename Value>
-tss_ptr<typename call_stack<Key, Value>::context>
-call_stack<Key, Value>::top_;
+template <typename Owner>
+tss_ptr<typename call_stack<Owner>::context>
+call_stack<Owner>::top_;
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // BOOST_ASIO_DETAIL_CALL_STACK_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/chrono_time_traits.hpp b/3rdParty/Boost/src/boost/asio/detail/chrono_time_traits.hpp
deleted file mode 100644
index e56c8c3..0000000
--- a/3rdParty/Boost/src/boost/asio/detail/chrono_time_traits.hpp
+++ /dev/null
@@ -1,129 +0,0 @@
-//
-// detail/chrono_time_traits.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_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/push_options.hpp>
-
-namespace boost {
-namespace asio {
-namespace detail {
-
-// 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;
-
-  // The duration type of the clock.
-  typedef typename clock_type::duration duration_type;
-
-  // The time point type of the clock.
-  typedef typename clock_type::time_point time_type;
-
-  // The period of the clock.
-  typedef typename duration_type::period period_type;
-
-  // Get the current time.
-  static time_type now()
-  {
-    return clock_type::now();
-  }
-
-  // Add a duration to a time.
-  static time_type add(const time_type& t, const duration_type& d)
-  {
-    return t + d;
-  }
-
-  // Subtract one time from another.
-  static duration_type subtract(const time_type& t1, const time_type& t2)
-  {
-    return t1 - t2;
-  }
-
-  // Test whether one time is less than another.
-  static bool less_than(const time_type& t1, const time_type& t2)
-  {
-    return t1 < t2;
-  }
-
-  // Implement just enough of the posix_time::time_duration interface to supply
-  // what the timer_queue requires.
-  class posix_time_duration
-  {
-  public:
-    explicit posix_time_duration(const duration_type& d)
-      : d_(d)
-    {
-    }
-
-    boost::int64_t ticks() const
-    {
-      return d_.count();
-    }
-
-    boost::int64_t total_seconds() const
-    {
-      return duration_cast<1, 1>();
-    }
-
-    boost::int64_t total_milliseconds() const
-    {
-      return duration_cast<1, 1000>();
-    }
-
-    boost::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
-    {
-      const boost::int64_t num = period_type::num * Den;
-      const boost::int64_t den = period_type::den * Num;
-
-      if (num == 1 && den == 1)
-        return ticks();
-      else if (num != 1 && den == 1)
-        return ticks() * num;
-      else if (num == 1 && period_type::den != 1)
-        return ticks() / den;
-      else
-        return ticks() * num / den;
-    }
-
-    duration_type d_;
-  };
-
-  // Convert to POSIX duration type.
-  static posix_time_duration to_posix_duration(const duration_type& d)
-  {
-    return posix_time_duration(WaitTraits::to_wait_duration(d));
-  }
-};
-
-} // namespace detail
-} // namespace asio
-} // namespace boost
-
-#include <boost/asio/detail/pop_options.hpp>
-
-#endif // BOOST_ASIO_DETAIL_CHRONO_TIME_TRAITS_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/completion_handler.hpp b/3rdParty/Boost/src/boost/asio/detail/completion_handler.hpp
index 19b4360..3b023d1 100644
--- a/3rdParty/Boost/src/boost/asio/detail/completion_handler.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/completion_handler.hpp
@@ -1,82 +1,77 @@
 //
 // detail/completion_handler.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_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/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>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 template <typename Handler>
 class completion_handler : public operation
 {
 public:
   BOOST_ASIO_DEFINE_HANDLER_PTR(completion_handler);
 
-  completion_handler(Handler& h)
+  completion_handler(Handler h)
     : operation(&completion_handler::do_complete),
-      handler_(BOOST_ASIO_MOVE_CAST(Handler)(h))
+      handler_(h)
   {
   }
 
   static void do_complete(io_service_impl* owner, operation* base,
-      const boost::system::error_code& /*ec*/,
-      std::size_t /*bytes_transferred*/)
+      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 };
 
-    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_));
+    Handler handler(h->handler_);
     p.h = boost::addressof(handler);
     p.reset();
 
     // Make the upcall if required.
     if (owner)
     {
-      fenced_block b(fenced_block::half);
-      BOOST_ASIO_HANDLER_INVOCATION_BEGIN(());
+      boost::asio::detail::fenced_block b;
       boost_asio_handler_invoke_helpers::invoke(handler, handler);
-      BOOST_ASIO_HANDLER_INVOCATION_END;
     }
   }
 
 private:
   Handler handler_;
 };
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // BOOST_ASIO_DETAIL_COMPLETION_HANDLER_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/config.hpp b/3rdParty/Boost/src/boost/asio/detail/config.hpp
index c47c007..45c2415 100644
--- a/3rdParty/Boost/src/boost/asio/detail/config.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/config.hpp
@@ -1,229 +1,83 @@
 //
 // detail/config.hpp
 // ~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_CONFIG_HPP
 #define BOOST_ASIO_DETAIL_CONFIG_HPP
 
 #include <boost/config.hpp>
-#include <boost/version.hpp>
 
 // 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
 #  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)
 // 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(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)
 
-// 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 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&&>
-#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
-// value.
-#if !defined(BOOST_ASIO_MOVE_CAST)
-# 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)
-#  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
-
-// 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)
-
-// 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)
-
-// Compliant C++11 compilers put noexcept specifiers on error_category members.
-#if !defined(BOOST_ASIO_ERROR_CATEGORY_NOEXCEPT)
-# if 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)
-
-// 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)
-
-// 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)
-
-// 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)
-
-// 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)
-
 // Windows: target OS version.
 #if defined(BOOST_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"\
   "Assuming _WIN32_WINNT=0x0501 (i.e. Windows XP target).")
 #  else // defined(_MSC_VER) || defined(__BORLANDC__)
 #   warning Please define _WIN32_WINNT or _WIN32_WINDOWS appropriately.
 #   warning For example, add -D_WIN32_WINNT=0x0501 to the compiler command line.
 #   warning Assuming _WIN32_WINNT=0x0501 (i.e. Windows XP target).
 #  endif // defined(_MSC_VER) || defined(__BORLANDC__)
 #  define _WIN32_WINNT 0x0501
 # endif // !defined(_WIN32_WINNT) && !defined(_WIN32_WINDOWS)
 # if defined(_MSC_VER)
 #  if defined(_WIN32) && !defined(WIN32)
 #   if !defined(_WINSOCK2API_)
 #    define WIN32 // Needed for correct types in winsock2.h
 #   else // !defined(_WINSOCK2API_)
 #    error Please define the macro WIN32 in your compiler options
 #   endif // !defined(_WINSOCK2API_)
 #  endif // defined(_WIN32) && !defined(WIN32)
 # endif // defined(_MSC_VER)
 # if defined(__BORLANDC__)
 #  if defined(__WIN32__) && !defined(WIN32)
 #   if !defined(_WINSOCK2API_)
 #    define WIN32 // Needed for correct types in winsock2.h
 #   else // !defined(_WINSOCK2API_)
 #    error Please define the macro WIN32 in your compiler options
 #   endif // !defined(_WINSOCK2API_)
 #  endif // defined(__WIN32__) && !defined(WIN32)
 # endif // defined(__BORLANDC__)
 # if defined(__CYGWIN__)
@@ -295,95 +149,57 @@
        //   || 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)
 #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__)
 
 // 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)
 
 // 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)
 
-// 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)
-
 // 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)
 
 // 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)
 
 // 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)
 
-// 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)
-
-// 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)
-
-// 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
-#    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__)
-#endif // !defined(BOOST_ASIO_DISABLE_THREAD_KEYWORD_EXTENSION)
-
 #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..f50d4e0 100644
--- a/3rdParty/Boost/src/boost/asio/detail/consuming_buffers.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/consuming_buffers.hpp
@@ -1,40 +1,40 @@
 //
 // detail/consuming_buffers.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_CONSUMING_BUFFERS_HPP
 #define BOOST_ASIO_DETAIL_CONSUMING_BUFFERS_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/iterator.hpp>
 #include <boost/limits.hpp>
 #include <boost/asio/buffer.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:
   // Default constructor creates an end iterator.
   consuming_buffers_iterator()
     : at_end_(true)
   {
   }
diff --git a/3rdParty/Boost/src/boost/asio/detail/date_time_fwd.hpp b/3rdParty/Boost/src/boost/asio/detail/date_time_fwd.hpp
deleted file mode 100644
index 162ccdc..0000000
--- a/3rdParty/Boost/src/boost/asio/detail/date_time_fwd.hpp
+++ /dev/null
@@ -1,34 +0,0 @@
-//
-// detail/date_time_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_DATE_TIME_FWD_HPP
-#define BOOST_ASIO_DETAIL_DATE_TIME_FWD_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include <boost/asio/detail/config.hpp>
-
-namespace boost {
-namespace date_time {
-
-template<class T, class TimeSystem>
-class base_time;
-
-} // namespace date_time
-namespace posix_time {
-
-class ptime;
-
-} // namespace posix_time
-} // namespace boost
-
-#endif // 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..82e0d43 100644
--- a/3rdParty/Boost/src/boost/asio/detail/deadline_timer_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/deadline_timer_service.hpp
@@ -1,216 +1,188 @@
 //
 // detail/deadline_timer_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_DEADLINE_TIMER_SERVICE_HPP
 #define BOOST_ASIO_DETAIL_DEADLINE_TIMER_SERVICE_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/error.hpp>
 #include <boost/asio/io_service.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_op.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>
+
+#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>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 template <typename Time_Traits>
 class deadline_timer_service
 {
 public:
   // The time type.
   typedef typename Time_Traits::time_type time_type;
 
   // The duration type.
   typedef typename Time_Traits::duration_type duration_type;
 
   // The implementation type of the timer. This type is dependent on the
   // underlying implementation of the timer service.
   struct implementation_type
     : private boost::asio::detail::noncopyable
   {
     time_type expiry;
     bool might_have_pending_waits;
     typename timer_queue<Time_Traits>::per_timer_data timer_data;
   };
 
   // Constructor.
   deadline_timer_service(boost::asio::io_service& io_service)
     : scheduler_(boost::asio::use_service<timer_scheduler>(io_service))
   {
     scheduler_.init_task();
     scheduler_.add_timer_queue(timer_queue_);
   }
 
   // Destructor.
   ~deadline_timer_service()
   {
     scheduler_.remove_timer_queue(timer_queue_);
   }
 
   // Destroy all user-defined handler objects owned by the service.
   void shutdown_service()
   {
   }
 
   // Construct a new timer implementation.
   void construct(implementation_type& impl)
   {
     impl.expiry = time_type();
     impl.might_have_pending_waits = false;
   }
 
   // Destroy a timer implementation.
   void destroy(implementation_type& impl)
   {
     boost::system::error_code ec;
     cancel(impl, ec);
   }
 
   // Cancel any asynchronous wait operations associated with the timer.
   std::size_t cancel(implementation_type& impl, boost::system::error_code& ec)
   {
     if (!impl.might_have_pending_waits)
     {
       ec = boost::system::error_code();
       return 0;
     }
-
-    BOOST_ASIO_HANDLER_OPERATION(("deadline_timer", &impl, "cancel"));
-
     std::size_t count = scheduler_.cancel_timer(timer_queue_, impl.timer_data);
     impl.might_have_pending_waits = false;
     ec = boost::system::error_code();
     return count;
   }
 
-  // Cancels one asynchronous wait operation associated with the timer.
-  std::size_t cancel_one(implementation_type& impl,
-      boost::system::error_code& ec)
-  {
-    if (!impl.might_have_pending_waits)
-    {
-      ec = boost::system::error_code();
-      return 0;
-    }
-
-    BOOST_ASIO_HANDLER_OPERATION(("deadline_timer", &impl, "cancel_one"));
-
-    std::size_t count = scheduler_.cancel_timer(
-        timer_queue_, impl.timer_data, 1);
-    if (count == 0)
-      impl.might_have_pending_waits = false;
-    ec = boost::system::error_code();
-    return count;
-  }
-
   // Get the expiry time for the timer as an absolute time.
   time_type expires_at(const implementation_type& impl) const
   {
     return impl.expiry;
   }
 
   // Set the expiry time for the timer as an absolute time.
   std::size_t expires_at(implementation_type& impl,
       const time_type& expiry_time, boost::system::error_code& ec)
   {
     std::size_t count = cancel(impl, ec);
     impl.expiry = expiry_time;
     ec = boost::system::error_code();
     return count;
   }
 
   // Get the expiry time for the timer relative to now.
   duration_type expires_from_now(const implementation_type& impl) const
   {
     return Time_Traits::subtract(expires_at(impl), Time_Traits::now());
   }
 
   // Set the expiry time for the timer relative to now.
   std::size_t expires_from_now(implementation_type& impl,
       const duration_type& expiry_time, boost::system::error_code& ec)
   {
     return expires_at(impl,
         Time_Traits::add(Time_Traits::now(), expiry_time), ec);
   }
 
   // Perform a blocking wait on the timer.
   void wait(implementation_type& impl, boost::system::error_code& ec)
   {
     time_type now = Time_Traits::now();
-    ec = boost::system::error_code();
-    while (Time_Traits::less_than(now, impl.expiry) && !ec)
+    while (Time_Traits::less_than(now, impl.expiry))
     {
-      this->do_wait(Time_Traits::to_posix_duration(
-            Time_Traits::subtract(impl.expiry, now)), ec);
+      boost::posix_time::time_duration timeout =
+        Time_Traits::to_posix_duration(Time_Traits::subtract(impl.expiry, now));
+      ::timeval tv;
+      tv.tv_sec = timeout.total_seconds();
+      tv.tv_usec = timeout.total_microseconds() % 1000000;
+      boost::system::error_code ec;
+      socket_ops::select(0, 0, 0, 0, &tv, ec);
       now = Time_Traits::now();
     }
+    ec = boost::system::error_code();
   }
 
   // Start an asynchronous wait on the timer.
   template <typename 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),
       boost_asio_handler_alloc_helpers::allocate(
         sizeof(op), handler), 0 };
     p.p = new (p.v) op(handler);
 
     impl.might_have_pending_waits = true;
 
-    BOOST_ASIO_HANDLER_CREATION((p.p, "deadline_timer", &impl, "async_wait"));
-
     scheduler_.schedule_timer(timer_queue_, impl.expiry, impl.timer_data, p.p);
     p.v = p.p = 0;
   }
 
 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)
-  {
-    ::timeval tv;
-    tv.tv_sec = timeout.total_seconds();
-    tv.tv_usec = timeout.total_microseconds() % 1000000;
-    socket_ops::select(0, 0, 0, 0, &tv, ec);
-  }
-
   // The queue of timers.
   timer_queue<Time_Traits> timer_queue_;
 
   // The object that schedules and executes timers. Usually a reactor.
   timer_scheduler& scheduler_;
 };
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // BOOST_ASIO_DETAIL_DEADLINE_TIMER_SERVICE_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/dependent_type.hpp b/3rdParty/Boost/src/boost/asio/detail/dependent_type.hpp
deleted file mode 100644
index c7b1c1b..0000000
--- a/3rdParty/Boost/src/boost/asio/detail/dependent_type.hpp
+++ /dev/null
@@ -1,38 +0,0 @@
-//
-// detail/dependent_type.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_DEPENDENT_TYPE_HPP
-#define BOOST_ASIO_DETAIL_DEPENDENT_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 {
-namespace detail {
-
-template <typename DependsOn, typename T>
-struct dependent_type
-{
-  typedef T type;
-};
-
-} // namespace detail
-} // namespace asio
-} // namespace boost
-
-#include <boost/asio/detail/pop_options.hpp>
-
-#endif // 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..f92a7b4 100644
--- a/3rdParty/Boost/src/boost/asio/detail/descriptor_ops.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/descriptor_ops.hpp
@@ -1,115 +1,107 @@
 //
 // detail/descriptor_ops.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_DESCRIPTOR_OPS_HPP
 #define BOOST_ASIO_DETAIL_DESCRIPTOR_OPS_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_WINDOWS) && !defined(__CYGWIN__)
 
 #include <cstddef>
 #include <boost/system/error_code.hpp>
 #include <boost/asio/detail/socket_types.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 namespace descriptor_ops {
 
 // Descriptor state bits.
 enum
 {
   // The user wants a non-blocking descriptor.
   user_set_non_blocking = 1,
 
   // The descriptor has been set non-blocking.
   internal_non_blocking = 2,
 
   // Helper "state" used to determine whether the descriptor is non-blocking.
-  non_blocking = user_set_non_blocking | internal_non_blocking,
-
-  // The descriptor may have been dup()-ed.
-  possible_dup = 4
+  non_blocking = user_set_non_blocking | internal_non_blocking
 };
 
 typedef unsigned char state_type;
 
 template <typename ReturnType>
 inline ReturnType error_wrapper(ReturnType return_value,
     boost::system::error_code& ec)
 {
   ec = boost::system::error_code(errno,
       boost::asio::error::get_system_category());
   return return_value;
 }
 
 BOOST_ASIO_DECL int open(const char* path, int flags,
     boost::system::error_code& ec);
 
 BOOST_ASIO_DECL int close(int d, state_type& state,
     boost::system::error_code& ec);
 
-BOOST_ASIO_DECL bool set_user_non_blocking(int d,
-    state_type& state, bool value, boost::system::error_code& ec);
-
 BOOST_ASIO_DECL bool set_internal_non_blocking(int d,
-    state_type& state, bool value, boost::system::error_code& ec);
+    state_type& state, boost::system::error_code& ec);
 
 typedef iovec buf;
 
 BOOST_ASIO_DECL std::size_t sync_read(int d, state_type state, buf* bufs,
     std::size_t count, bool all_empty, boost::system::error_code& ec);
 
 BOOST_ASIO_DECL bool non_blocking_read(int d, buf* bufs, std::size_t count,
     boost::system::error_code& ec, std::size_t& bytes_transferred);
 
 BOOST_ASIO_DECL std::size_t sync_write(int d, state_type state,
     const buf* bufs, std::size_t count, bool all_empty,
     boost::system::error_code& ec);
 
 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, long 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_read(int d, boost::system::error_code& ec);
 
-BOOST_ASIO_DECL int poll_write(int d,
-    state_type state, boost::system::error_code& ec);
+BOOST_ASIO_DECL int poll_write(int d, boost::system::error_code& ec);
 
 } // namespace descriptor_ops
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #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 // 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..884f8f6 100644
--- a/3rdParty/Boost/src/boost/asio/detail/descriptor_read_op.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/descriptor_read_op.hpp
@@ -1,121 +1,116 @@
 //
 // detail/descriptor_read_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_DESCRIPTOR_READ_OP_HPP
 #define BOOST_ASIO_DETAIL_DESCRIPTOR_READ_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_WINDOWS) && !defined(__CYGWIN__)
 
 #include <boost/utility/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>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 template <typename MutableBufferSequence>
 class descriptor_read_op_base : public reactor_op
 {
 public:
   descriptor_read_op_base(int descriptor,
       const MutableBufferSequence& buffers, func_type complete_func)
     : reactor_op(&descriptor_read_op_base::do_perform, complete_func),
       descriptor_(descriptor),
       buffers_(buffers)
   {
   }
 
   static bool do_perform(reactor_op* base)
   {
     descriptor_read_op_base* o(static_cast<descriptor_read_op_base*>(base));
 
     buffer_sequence_adapter<boost::asio::mutable_buffer,
         MutableBufferSequence> bufs(o->buffers_);
 
     return descriptor_ops::non_blocking_read(o->descriptor_,
         bufs.buffers(), bufs.count(), o->ec_, o->bytes_transferred_);
   }
 
 private:
   int descriptor_;
   MutableBufferSequence buffers_;
 };
 
 template <typename MutableBufferSequence, typename Handler>
 class descriptor_read_op
   : public descriptor_read_op_base<MutableBufferSequence>
 {
 public:
   BOOST_ASIO_DEFINE_HANDLER_PTR(descriptor_read_op);
 
   descriptor_read_op(int descriptor,
-      const MutableBufferSequence& buffers, Handler& handler)
+      const MutableBufferSequence& buffers, Handler handler)
     : descriptor_read_op_base<MutableBufferSequence>(
         descriptor, buffers, &descriptor_read_op::do_complete),
-      handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler))
+      handler_(handler)
   {
   }
 
   static void do_complete(io_service_impl* owner, operation* base,
-      const boost::system::error_code& /*ec*/,
-      std::size_t /*bytes_transferred*/)
+      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 };
 
-    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.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::detail::fenced_block b;
       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_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..805eb0b 100644
--- a/3rdParty/Boost/src/boost/asio/detail/descriptor_write_op.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/descriptor_write_op.hpp
@@ -1,121 +1,116 @@
 //
 // detail/descriptor_write_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_DESCRIPTOR_WRITE_OP_HPP
 #define BOOST_ASIO_DETAIL_DESCRIPTOR_WRITE_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_WINDOWS) && !defined(__CYGWIN__)
 
 #include <boost/utility/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>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 template <typename ConstBufferSequence>
 class descriptor_write_op_base : public reactor_op
 {
 public:
   descriptor_write_op_base(int descriptor,
       const ConstBufferSequence& buffers, func_type complete_func)
     : reactor_op(&descriptor_write_op_base::do_perform, complete_func),
       descriptor_(descriptor),
       buffers_(buffers)
   {
   }
 
   static bool do_perform(reactor_op* base)
   {
     descriptor_write_op_base* o(static_cast<descriptor_write_op_base*>(base));
 
     buffer_sequence_adapter<boost::asio::const_buffer,
         ConstBufferSequence> bufs(o->buffers_);
 
     return descriptor_ops::non_blocking_write(o->descriptor_,
         bufs.buffers(), bufs.count(), o->ec_, o->bytes_transferred_);
   }
 
 private:
   int descriptor_;
   ConstBufferSequence buffers_;
 };
 
 template <typename ConstBufferSequence, typename Handler>
 class descriptor_write_op
   : public descriptor_write_op_base<ConstBufferSequence>
 {
 public:
   BOOST_ASIO_DEFINE_HANDLER_PTR(descriptor_write_op);
 
   descriptor_write_op(int descriptor,
-      const ConstBufferSequence& buffers, Handler& handler)
+      const ConstBufferSequence& buffers, Handler handler)
     : descriptor_write_op_base<ConstBufferSequence>(
         descriptor, buffers, &descriptor_write_op::do_complete),
-      handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler))
+      handler_(handler)
   {
   }
 
   static void do_complete(io_service_impl* owner, operation* base,
-      const boost::system::error_code& /*ec*/,
-      std::size_t /*bytes_transferred*/)
+      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 };
 
-    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.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::detail::fenced_block b;
       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_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..79c1cbb 100644
--- a/3rdParty/Boost/src/boost/asio/detail/dev_poll_reactor.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/dev_poll_reactor.hpp
@@ -1,203 +1,177 @@
 //
 // detail/dev_poll_reactor.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_DEV_POLL_REACTOR_HPP
 #define BOOST_ASIO_DETAIL_DEV_POLL_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_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/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_op.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>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 class dev_poll_reactor
   : public boost::asio::detail::service_base<dev_poll_reactor>
 {
 public:
   enum op_types { read_op = 0, write_op = 1,
     connect_op = 1, except_op = 2, max_ops = 3 };
 
   // Per-descriptor data.
   struct per_descriptor_data
   {
   };
 
   // Constructor.
   BOOST_ASIO_DECL dev_poll_reactor(boost::asio::io_service& io_service);
 
   // Destructor.
   BOOST_ASIO_DECL ~dev_poll_reactor();
 
   // 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.
   BOOST_ASIO_DECL void init_task();
 
   // Register a socket with the reactor. Returns 0 on success, system error
   // code on failure.
   BOOST_ASIO_DECL int register_descriptor(socket_type, per_descriptor_data&);
 
-  // Register a descriptor with an associated single operation. Returns 0 on
-  // 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);
-
-  // 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)
   {
     io_service_.post_immediate_completion(op);
   }
 
   // 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);
 
   // 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&);
 
   // Cancel any operations that are running against the descriptor and remove
   // its registration from the reactor.
-  BOOST_ASIO_DECL void deregister_descriptor(socket_type descriptor,
-      per_descriptor_data&, bool closing);
-
-  // Cancel any operations that are running against the descriptor and remove
-  // its registration from the reactor.
-  BOOST_ASIO_DECL void deregister_internal_descriptor(
+  BOOST_ASIO_DECL void close_descriptor(
       socket_type descriptor, per_descriptor_data&);
 
   // 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);
+      typename timer_queue<Time_Traits>::per_timer_data& timer, timer_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)());
+      typename timer_queue<Time_Traits>::per_timer_data& timer);
 
   // Run /dev/poll once until interrupted or events are ready to be dispatched.
   BOOST_ASIO_DECL void run(bool block, op_queue<operation>& ops);
 
   // Interrupt the select loop.
   BOOST_ASIO_DECL void interrupt();
 
 private:
   // Create the /dev/poll file descriptor. Throws an exception if the descriptor
   // cannot be created.
   BOOST_ASIO_DECL static int do_dev_poll_create();
 
   // 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);
 
   // Get the timeout value for the /dev/poll DP_POLL operation. The timeout
   // value is returned as a number of milliseconds. A return value of -1
   // indicates that the poll should block indefinitely.
   BOOST_ASIO_DECL int get_timeout();
 
   // Cancel all operations associated with the given descriptor. The do_cancel
   // function of the handler objects will be invoked. This function does not
   // acquire the dev_poll_reactor's mutex.
   BOOST_ASIO_DECL void cancel_ops_unlocked(socket_type descriptor,
       const boost::system::error_code& ec);
 
-  // Helper class used to reregister descriptors after a fork.
-  class fork_helper;
-  friend class fork_helper;
-
   // Add a pending event entry for the given descriptor.
   BOOST_ASIO_DECL ::pollfd& add_pending_event_change(int descriptor);
 
   // The io_service implementation used to post completions.
   io_service_impl& io_service_;
 
   // Mutex to protect access to internal data.
   boost::asio::detail::mutex mutex_;
 
   // The /dev/poll file descriptor.
   int dev_poll_fd_;
 
   // Vector of /dev/poll events waiting to be written to the descriptor.
   std::vector< ::pollfd> pending_event_changes_;
 
   // Hash map to associate a descriptor with a pending event change index.
   hash_map<int, std::size_t> pending_event_change_index_;
 
   // The interrupter is used to break a blocking DP_POLL operation.
   select_interrupter interrupter_;
 
   // The queues of read, write and except operations.
   reactor_op_queue<socket_type> op_queue_[max_ops];
 
   // The timer queues.
   timer_queue_set timer_queues_;
 
   // Whether the service has been shut down.
   bool shutdown_;
 };
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
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
index 026f91a..c5ceab2 100644
--- a/3rdParty/Boost/src/boost/asio/detail/dev_poll_reactor_fwd.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/dev_poll_reactor_fwd.hpp
@@ -1,34 +1,34 @@
 //
 // detail/dev_poll_reactor_fwd.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_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..1889017 100644
--- a/3rdParty/Boost/src/boost/asio/detail/epoll_reactor.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/epoll_reactor.hpp
@@ -1,247 +1,199 @@
 //
 // detail/epoll_reactor.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_EPOLL_REACTOR_HPP
 #define BOOST_ASIO_DETAIL_EPOLL_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_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/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_op.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 {
 namespace asio {
 namespace detail {
 
 class epoll_reactor
   : public boost::asio::detail::service_base<epoll_reactor>
 {
 public:
   enum op_types { read_op = 0, write_op = 1,
     connect_op = 1, except_op = 2, max_ops = 3 };
 
   // Per-descriptor queues.
-  class descriptor_state : operation
+  class descriptor_state
   {
     friend class epoll_reactor;
     friend class object_pool_access;
-
-    descriptor_state* next_;
-    descriptor_state* prev_;
-
     mutex mutex_;
-    epoll_reactor* reactor_;
-    int descriptor_;
-    boost::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);
-    BOOST_ASIO_DECL static void do_complete(
-        io_service_impl* owner, operation* base,
-        const boost::system::error_code& ec, std::size_t bytes_transferred);
+    descriptor_state* next_;
+    descriptor_state* prev_;
   };
 
   // Per-descriptor data.
   typedef descriptor_state* per_descriptor_data;
 
   // Constructor.
   BOOST_ASIO_DECL epoll_reactor(boost::asio::io_service& io_service);
 
   // Destructor.
   BOOST_ASIO_DECL ~epoll_reactor();
 
   // 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.
   BOOST_ASIO_DECL void init_task();
 
   // Register a socket with the reactor. Returns 0 on success, system error
   // code on failure.
   BOOST_ASIO_DECL int register_descriptor(socket_type descriptor,
       per_descriptor_data& descriptor_data);
 
-  // Register a descriptor with an associated single operation. Returns 0 on
-  // 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);
-
-  // 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)
   {
     io_service_.post_immediate_completion(op);
   }
 
   // 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 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);
 
   // Cancel any operations that are running against the descriptor and remove
   // its registration from the reactor.
-  BOOST_ASIO_DECL void deregister_descriptor(socket_type descriptor,
-      per_descriptor_data& descriptor_data, bool closing);
-
-  // Remote the descriptor's registration from the reactor.
-  BOOST_ASIO_DECL void deregister_internal_descriptor(
-      socket_type descriptor, per_descriptor_data& descriptor_data);
+  BOOST_ASIO_DECL void close_descriptor(socket_type descriptor,
+      per_descriptor_data& descriptor_data);
 
   // Add a new timer queue to the reactor.
   template <typename Time_Traits>
   void add_timer_queue(timer_queue<Time_Traits>& timer_queue);
 
   // Remove a timer queue from the reactor.
   template <typename Time_Traits>
   void remove_timer_queue(timer_queue<Time_Traits>& timer_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);
+      typename timer_queue<Time_Traits>::per_timer_data& timer, timer_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)());
+      typename timer_queue<Time_Traits>::per_timer_data& timer);
 
   // Run epoll once until interrupted or events are ready to be dispatched.
   BOOST_ASIO_DECL void run(bool block, op_queue<operation>& ops);
 
   // Interrupt the select loop.
   BOOST_ASIO_DECL void interrupt();
 
 private:
   // The hint to pass to epoll_create to size its data structures.
   enum { epoll_size = 20000 };
 
   // Create the epoll file descriptor. Throws an exception if the descriptor
   // cannot be created.
   BOOST_ASIO_DECL static int do_epoll_create();
 
-  // Create the timerfd file descriptor. Does not throw.
-  BOOST_ASIO_DECL static int do_timerfd_create();
-
-  // Allocate a new descriptor state object.
-  BOOST_ASIO_DECL descriptor_state* allocate_descriptor_state();
-
-  // Free an existing descriptor state object.
-  BOOST_ASIO_DECL void free_descriptor_state(descriptor_state* s);
-
   // 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);
 
   // Called to recalculate and update the timeout.
   BOOST_ASIO_DECL void update_timeout();
 
   // Get the timeout value for the epoll_wait call. The timeout value is
   // returned as a number of milliseconds. A return value of -1 indicates
   // that epoll_wait should block indefinitely.
   BOOST_ASIO_DECL int get_timeout();
 
 #if defined(BOOST_ASIO_HAS_TIMERFD)
   // Get the timeout value for the timer descriptor. The return value is the
   // flag argument to be used when calling timerfd_settime.
   BOOST_ASIO_DECL int get_timeout(itimerspec& ts);
 #endif // defined(BOOST_ASIO_HAS_TIMERFD)
 
   // The io_service implementation used to post completions.
   io_service_impl& io_service_;
 
   // Mutex to protect access to internal data.
   mutex mutex_;
 
-  // The interrupter is used to break a blocking epoll_wait call.
-  select_interrupter interrupter_;
-
   // The epoll file descriptor.
   int epoll_fd_;
 
   // The timer file descriptor.
   int timer_fd_;
 
+  // The interrupter is used to break a blocking epoll_wait call.
+  select_interrupter interrupter_;
+
   // The timer queues.
   timer_queue_set timer_queues_;
 
   // Whether the service has been shut down.
   bool shutdown_;
 
   // Mutex to protect access to the registered descriptors.
   mutex registered_descriptors_mutex_;
 
   // Keep track of all registered descriptors.
   object_pool<descriptor_state> registered_descriptors_;
-
-  // Helper class to do post-perform_io cleanup.
-  struct perform_io_cleanup_on_block_exit;
-  friend struct perform_io_cleanup_on_block_exit;
 };
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #include <boost/asio/detail/impl/epoll_reactor.hpp>
 #if defined(BOOST_ASIO_HEADER_ONLY)
 # include <boost/asio/detail/impl/epoll_reactor.ipp>
 #endif // defined(BOOST_ASIO_HEADER_ONLY)
 
 #endif // defined(BOOST_ASIO_HAS_EPOLL)
 
 #endif // BOOST_ASIO_DETAIL_EPOLL_REACTOR_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/epoll_reactor_fwd.hpp b/3rdParty/Boost/src/boost/asio/detail/epoll_reactor_fwd.hpp
index aa28271..01ee84c 100644
--- a/3rdParty/Boost/src/boost/asio/detail/epoll_reactor_fwd.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/epoll_reactor_fwd.hpp
@@ -1,34 +1,34 @@
 //
 // detail/epoll_reactor_fwd.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_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..c8109d1 100644
--- a/3rdParty/Boost/src/boost/asio/detail/event.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/event.hpp
@@ -1,40 +1,40 @@
 //
 // detail/event.hpp
 // ~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_EVENT_HPP
 #define BOOST_ASIO_DETAIL_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_HAS_THREADS) || defined(BOOST_ASIO_DISABLE_THREADS)
 # include <boost/asio/detail/null_event.hpp>
 #elif defined(BOOST_WINDOWS)
 # include <boost/asio/detail/win_event.hpp>
 #elif defined(BOOST_HAS_PTHREADS)
 # include <boost/asio/detail/posix_event.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)
 typedef null_event event;
 #elif defined(BOOST_WINDOWS)
 typedef win_event event;
 #elif defined(BOOST_HAS_PTHREADS)
 typedef posix_event event;
 #endif
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..954fe79 100644
--- a/3rdParty/Boost/src/boost/asio/detail/eventfd_select_interrupter.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/eventfd_select_interrupter.hpp
@@ -1,85 +1,76 @@
 //
 // detail/eventfd_select_interrupter.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2011 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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_EVENTFD_SELECT_INTERRUPTER_HPP
 #define BOOST_ASIO_DETAIL_EVENTFD_SELECT_INTERRUPTER_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_EVENTFD)
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 class eventfd_select_interrupter
 {
 public:
   // Constructor.
   BOOST_ASIO_DECL eventfd_select_interrupter();
 
   // Destructor.
   BOOST_ASIO_DECL ~eventfd_select_interrupter();
 
-  // Recreate the interrupter's descriptors. Used after a fork.
-  BOOST_ASIO_DECL void recreate();
-
   // Interrupt the select call.
   BOOST_ASIO_DECL void interrupt();
 
   // Reset the select interrupt. Returns true if the call was interrupted.
   BOOST_ASIO_DECL bool reset();
 
   // Get the read descriptor to be passed to select.
   int read_descriptor() const
   {
     return read_descriptor_;
   }
 
 private:
-  // Open the descriptors. Throws on error.
-  BOOST_ASIO_DECL void open_descriptors();
-
-  // Close the descriptors.
-  BOOST_ASIO_DECL void close_descriptors();
-
   // The read end of a connection used to interrupt the select call. This file
   // descriptor is passed to select such that when it is time to stop, a single
   // 64bit value will be written on the other end of the connection and this
   // descriptor will become readable.
   int read_descriptor_;
 
   // The write end of a connection used to interrupt the select call. A single
   // 64bit non-zero value may be written to this to wake up the select which is
   // waiting for the other end to become readable. This descriptor will only
   // differ from the read descriptor when a pipe is used.
   int write_descriptor_;
 };
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #if defined(BOOST_ASIO_HEADER_ONLY)
 # include <boost/asio/detail/impl/eventfd_select_interrupter.ipp>
 #endif // defined(BOOST_ASIO_HEADER_ONLY)
 
 #endif // defined(BOOST_ASIO_HAS_EVENTFD)
 
 #endif // BOOST_ASIO_DETAIL_EVENTFD_SELECT_INTERRUPTER_HPP
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..8df0426 100644
--- a/3rdParty/Boost/src/boost/asio/detail/fd_set_adapter.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/fd_set_adapter.hpp
@@ -1,36 +1,36 @@
 //
 // detail/fd_set_adapter.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_FD_SET_ADAPTER_HPP
 #define BOOST_ASIO_DETAIL_FD_SET_ADAPTER_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/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__)
 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 // 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..4cb27dc 100644
--- a/3rdParty/Boost/src/boost/asio/detail/fenced_block.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/fenced_block.hpp
@@ -1,80 +1,78 @@
 //
 // detail/fenced_block.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_FENCED_BLOCK_HPP
 #define BOOST_ASIO_DETAIL_FENCED_BLOCK_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_HAS_THREADS) \
   || defined(BOOST_ASIO_DISABLE_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>
-#elif defined(__GNUC__) && defined(__arm__) \
-  && !defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4)
+#elif defined(__GNUC__) && defined(__arm__)
 # include <boost/asio/detail/gcc_arm_fenced_block.hpp>
 #elif defined(__GNUC__) && (defined(__hppa) || defined(__hppa__))
 # include <boost/asio/detail/gcc_hppa_fenced_block.hpp>
-#elif defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
-# 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(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
+# include <boost/asio/detail/gcc_x86_fenced_block.hpp>
 #elif defined(BOOST_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) \
   || 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;
-#elif defined(__GNUC__) && defined(__arm__) \
-  && !defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4)
+#elif defined(__GNUC__) && defined(__arm__)
 typedef gcc_arm_fenced_block fenced_block;
 #elif defined(__GNUC__) && (defined(__hppa) || defined(__hppa__))
 typedef gcc_hppa_fenced_block fenced_block;
-#elif defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
-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(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
+typedef gcc_x86_fenced_block fenced_block;
 #elif defined(BOOST_WINDOWS) && !defined(UNDER_CE)
 typedef win_fenced_block fenced_block;
 #else
 typedef null_fenced_block fenced_block;
 #endif
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #endif // BOOST_ASIO_DETAIL_FENCED_BLOCK_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..58cdfb4 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,91 +1,78 @@
 //
 // detail/gcc_arm_fenced_block.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_GCC_ARM_FENCED_BLOCK_HPP
 #define BOOST_ASIO_DETAIL_GCC_ARM_FENCED_BLOCK_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(__GNUC__) && defined(__arm__)
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 class gcc_arm_fenced_block
   : private noncopyable
 {
 public:
-  enum half_t { half };
-  enum full_t { full };
-
-  // Constructor for a half fenced block.
-  explicit gcc_arm_fenced_block(half_t)
-  {
-  }
-
-  // Constructor for a full fenced block.
-  explicit gcc_arm_fenced_block(full_t)
+  // Constructor.
+  gcc_arm_fenced_block()
   {
     barrier();
   }
 
   // Destructor.
   ~gcc_arm_fenced_block()
   {
     barrier();
   }
 
 private:
   static void barrier()
   {
 #if defined(__ARM_ARCH_4__) \
     || defined(__ARM_ARCH_4T__) \
     || defined(__ARM_ARCH_5__) \
     || defined(__ARM_ARCH_5E__) \
     || defined(__ARM_ARCH_5T__) \
     || defined(__ARM_ARCH_5TE__) \
     || defined(__ARM_ARCH_5TEJ__) \
     || defined(__ARM_ARCH_6__) \
     || defined(__ARM_ARCH_6J__) \
     || defined(__ARM_ARCH_6K__) \
     || defined(__ARM_ARCH_6Z__) \
     || defined(__ARM_ARCH_6ZK__) \
     || defined(__ARM_ARCH_6T2__)
-# if defined(__thumb__)
-    // This is just a placeholder and almost certainly not sufficient.
-    __asm__ __volatile__ ("" : : : "memory");
-# else // defined(__thumb__)
     int a = 0, b = 0;
     __asm__ __volatile__ ("swp %0, %1, [%2]"
         : "=&r"(a) : "r"(1), "r"(&b) : "memory", "cc");
-# endif // defined(__thumb__)
 #else
     // ARMv7 and later.
     __asm__ __volatile__ ("dmb" : : : "memory");
 #endif
   }
 };
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // defined(__GNUC__) && defined(__arm__)
 
 #endif // 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..6c5226b 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,68 +1,60 @@
 //
 // detail/gcc_hppa_fenced_block.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_GCC_HPPA_FENCED_BLOCK_HPP
 #define BOOST_ASIO_DETAIL_GCC_HPPA_FENCED_BLOCK_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(__GNUC__) && (defined(__hppa) || defined(__hppa__))
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 class gcc_hppa_fenced_block
   : private noncopyable
 {
 public:
-  enum half_t { half };
-  enum full_t { full };
-
-  // Constructor for a half fenced block.
-  explicit gcc_hppa_fenced_block(half_t)
-  {
-  }
-
-  // Constructor for a full fenced block.
-  explicit gcc_hppa_fenced_block(full_t)
+  // Constructor.
+  gcc_hppa_fenced_block()
   {
     barrier();
   }
 
   // Destructor.
   ~gcc_hppa_fenced_block()
   {
     barrier();
   }
 
 private:
   static void barrier()
   {
     // This is just a placeholder and almost certainly not sufficient.
     __asm__ __volatile__ ("" : : : "memory");
   }
 };
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // defined(__GNUC__) && (defined(__hppa) || defined(__hppa__))
 
 #endif // 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..65472cc 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,65 +1,63 @@
 //
 // detail/gcc_sync_fenced_block.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_GCC_SYNC_FENCED_BLOCK_HPP
 #define BOOST_ASIO_DETAIL_GCC_SYNC_FENCED_BLOCK_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(__GNUC__) \
   && ((__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4)) \
   && !defined(__INTEL_COMPILER) && !defined(__ICL) \
   && !defined(__ICC) && !defined(__ECC) && !defined(__PATHSCALE__)
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 class gcc_sync_fenced_block
   : private noncopyable
 {
 public:
-  enum half_or_full_t { half, full };
-
   // Constructor.
-  explicit gcc_sync_fenced_block(half_or_full_t)
+  gcc_sync_fenced_block()
     : value_(0)
   {
     __sync_lock_test_and_set(&value_, 1);
   }
 
   // Destructor.
   ~gcc_sync_fenced_block()
   {
     __sync_lock_release(&value_);
   }
 
 private:
   int value_;
 };
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // defined(__GNUC__)
        // && ((__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4))
        // && !defined(__INTEL_COMPILER) && !defined(__ICL)
        // && !defined(__ICC) && !defined(__ECC) && !defined(__PATHSCALE__)
 
 #endif // 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..fb8473c 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,91 +1,61 @@
 //
 // detail/gcc_x86_fenced_block.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_GCC_X86_FENCED_BLOCK_HPP
 #define BOOST_ASIO_DETAIL_GCC_X86_FENCED_BLOCK_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(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 class gcc_x86_fenced_block
   : private noncopyable
 {
 public:
-  enum half_t { half };
-  enum full_t { full };
-
-  // Constructor for a half fenced block.
-  explicit gcc_x86_fenced_block(half_t)
-  {
-  }
-
-  // Constructor for a full fenced block.
-  explicit gcc_x86_fenced_block(full_t)
+  // Constructor.
+  gcc_x86_fenced_block()
   {
-    lbarrier();
+    barrier();
   }
 
   // Destructor.
   ~gcc_x86_fenced_block()
   {
-    sbarrier();
+    barrier();
   }
 
 private:
   static int barrier()
   {
-    int r = 0, m = 1;
-    __asm__ __volatile__ (
-        "xchgl %0, %1" :
-        "=r"(r), "=m"(m) :
-        "0"(1), "m"(m) :
-        "memory", "cc");
+    int r = 0;
+    __asm__ __volatile__ ("xchgl %%eax, %0" : "=m" (r) : : "memory", "cc");
     return r;
   }
-
-  static void lbarrier()
-  {
-#if defined(__SSE2__)
-    __asm__ __volatile__ ("lfence" ::: "memory");
-#else // defined(__SSE2__)
-    barrier();
-#endif // defined(__SSE2__)
-  }
-
-  static void sbarrier()
-  {
-#if defined(__SSE2__)
-    __asm__ __volatile__ ("sfence" ::: "memory");
-#else // defined(__SSE2__)
-    barrier();
-#endif // defined(__SSE2__)
-  }
 };
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
 
 #endif // BOOST_ASIO_DETAIL_GCC_X86_FENCED_BLOCK_HPP
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..fc3ec33 100644
--- a/3rdParty/Boost/src/boost/asio/detail/handler_alloc_helpers.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/handler_alloc_helpers.hpp
@@ -1,85 +1,85 @@
 //
 // detail/handler_alloc_helpers.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_HANDLER_ALLOC_HELPERS_HPP
 #define BOOST_ASIO_DETAIL_HANDLER_ALLOC_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/detail/workaround.hpp>
 #include <boost/utility/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
 // a namespace that does not contain any overloads of these functions. The
 // 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)
   return ::operator new(s);
 #else
-  using boost::asio::asio_handler_allocate;
+  using namespace boost::asio;
   return asio_handler_allocate(s, boost::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)
   ::operator delete(p);
 #else
-  using boost::asio::asio_handler_deallocate;
+  using namespace boost::asio;
   asio_handler_deallocate(p, s, boost::addressof(h));
 #endif
 }
 
 } // namespace boost_asio_handler_alloc_helpers
 
 #define BOOST_ASIO_DEFINE_HANDLER_PTR(op) \
   struct ptr \
   { \
     Handler* h; \
     void* v; \
     op* p; \
     ~ptr() \
     { \
       reset(); \
     } \
     void reset() \
     { \
       if (p) \
       { \
         p->~op(); \
         p = 0; \
       } \
       if (v) \
       { \
         boost_asio_handler_alloc_helpers::deallocate(v, sizeof(op), *h); \
         v = 0; \
       } \
     } \
   } \
   /**/
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // BOOST_ASIO_DETAIL_HANDLER_ALLOC_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..3b44997 100644
--- a/3rdParty/Boost/src/boost/asio/detail/handler_invoke_helpers.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/handler_invoke_helpers.hpp
@@ -1,60 +1,47 @@
 //
 // detail/handler_invoke_helpers.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_HANDLER_INVOKE_HELPERS_HPP
 #define BOOST_ASIO_DETAIL_HANDLER_INVOKE_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/detail/workaround.hpp>
 #include <boost/utility/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)
-  Function tmp(function);
-  tmp();
-#else
-  using boost::asio::asio_handler_invoke;
-  asio_handler_invoke(function, boost::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)
   Function tmp(function);
   tmp();
 #else
-  using boost::asio::asio_handler_invoke;
+  using namespace boost::asio;
   asio_handler_invoke(function, boost::addressof(context));
 #endif
 }
 
 } // namespace boost_asio_handler_invoke_helpers
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // BOOST_ASIO_DETAIL_HANDLER_INVOKE_HELPERS_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/handler_tracking.hpp b/3rdParty/Boost/src/boost/asio/detail/handler_tracking.hpp
deleted file mode 100644
index 9c96e18..0000000
--- a/3rdParty/Boost/src/boost/asio/detail/handler_tracking.hpp
+++ /dev/null
@@ -1,161 +0,0 @@
-//
-// detail/handler_tracking.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_HANDLER_TRACKING_HPP
-#define BOOST_ASIO_DETAIL_HANDLER_TRACKING_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_ENABLE_HANDLER_TRACKING)
-# include <boost/cstdint.hpp>
-# include <boost/system/error_code.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>
-
-namespace boost {
-namespace asio {
-namespace detail {
-
-#if defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING)
-
-class handler_tracking
-{
-public:
-  class completion;
-
-  // Base class for objects containing tracked handlers.
-  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_;
-
-  protected:
-    // Constructor initialises with no id.
-    tracked_handler() : id_(0) {}
-
-    // Prevent deletion through this type.
-    ~tracked_handler() {}
-  };
-
-  // Initialise the tracking system.
-  BOOST_ASIO_DECL static void init();
-
-  // Record the creation of a tracked handler.
-  BOOST_ASIO_DECL static void creation(tracked_handler* h,
-      const char* object_type, void* object, const char* op_name);
-
-  class completion
-  {
-  public:
-    // Constructor records that handler is to be invoked with no arguments.
-    BOOST_ASIO_DECL explicit completion(tracked_handler* h);
-
-    // Destructor records only when an exception is thrown from the handler, or
-    // if the memory is being freed without the handler having been invoked.
-    BOOST_ASIO_DECL ~completion();
-
-    // Records that handler is to be invoked with no arguments.
-    BOOST_ASIO_DECL void invocation_begin();
-
-    // Records that handler is to be invoked with one arguments.
-    BOOST_ASIO_DECL void invocation_begin(const boost::system::error_code& ec);
-
-    // Constructor records that handler is to be invoked with two arguments.
-    BOOST_ASIO_DECL void invocation_begin(
-        const boost::system::error_code& ec, std::size_t bytes_transferred);
-
-    // Constructor records that handler is to be invoked with two arguments.
-    BOOST_ASIO_DECL void invocation_begin(
-        const boost::system::error_code& ec, int signal_number);
-
-    // Constructor records that handler is to be invoked with two arguments.
-    BOOST_ASIO_DECL void invocation_begin(
-        const boost::system::error_code& ec, const char* arg);
-
-    // Record that handler invocation has ended.
-    BOOST_ASIO_DECL void invocation_end();
-
-  private:
-    friend class handler_tracking;
-    boost::uint64_t id_;
-    bool invoked_;
-    completion* next_;
-  };
-
-  // Record an operation that affects pending handlers.
-  BOOST_ASIO_DECL static void operation(const char* object_type,
-      void* object, const char* op_name);
-
-  // Write a line of output.
-  BOOST_ASIO_DECL static void write_line(const char* format, ...);
-
-private:
-  struct tracking_state;
-  BOOST_ASIO_DECL static tracking_state* get_state();
-};
-
-# define BOOST_ASIO_INHERIT_TRACKED_HANDLER \
-  : public boost::asio::detail::handler_tracking::tracked_handler
-
-# define BOOST_ASIO_ALSO_INHERIT_TRACKED_HANDLER \
-  , public boost::asio::detail::handler_tracking::tracked_handler
-
-# define BOOST_ASIO_HANDLER_TRACKING_INIT \
-  boost::asio::detail::handler_tracking::init()
-
-# define BOOST_ASIO_HANDLER_CREATION(args) \
-  boost::asio::detail::handler_tracking::creation args
-
-# define BOOST_ASIO_HANDLER_COMPLETION(args) \
-  boost::asio::detail::handler_tracking::completion tracked_completion args
-
-# define BOOST_ASIO_HANDLER_INVOCATION_BEGIN(args) \
-  tracked_completion.invocation_begin args
-
-# define BOOST_ASIO_HANDLER_INVOCATION_END \
-  tracked_completion.invocation_end()
-
-# define BOOST_ASIO_HANDLER_OPERATION(args) \
-  boost::asio::detail::handler_tracking::operation args
-
-#else // defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING)
-
-# define BOOST_ASIO_INHERIT_TRACKED_HANDLER
-# define BOOST_ASIO_ALSO_INHERIT_TRACKED_HANDLER
-# define BOOST_ASIO_HANDLER_TRACKING_INIT (void)0
-# define BOOST_ASIO_HANDLER_CREATION(args) (void)0
-# define BOOST_ASIO_HANDLER_COMPLETION(args) (void)0
-# define BOOST_ASIO_HANDLER_INVOCATION_BEGIN(args) (void)0
-# define BOOST_ASIO_HANDLER_INVOCATION_END (void)0
-# define BOOST_ASIO_HANDLER_OPERATION(args) (void)0
-
-#endif // defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING)
-
-} // namespace detail
-} // namespace asio
-} // namespace boost
-
-#include <boost/asio/detail/pop_options.hpp>
-
-#if defined(BOOST_ASIO_HEADER_ONLY)
-# include <boost/asio/detail/impl/handler_tracking.ipp>
-#endif // defined(BOOST_ASIO_HEADER_ONLY)
-
-#endif // BOOST_ASIO_DETAIL_HANDLER_TRACKING_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/handler_type_requirements.hpp b/3rdParty/Boost/src/boost/asio/detail/handler_type_requirements.hpp
deleted file mode 100644
index a7f47c2..0000000
--- a/3rdParty/Boost/src/boost/asio/detail/handler_type_requirements.hpp
+++ /dev/null
@@ -1,362 +0,0 @@
-//
-// detail/handler_type_requirements.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_HANDLER_TYPE_REQUIREMENTS_HPP
-#define BOOST_ASIO_DETAIL_HANDLER_TYPE_REQUIREMENTS_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include <boost/asio/detail/config.hpp>
-
-// Older versions of gcc have difficulty compiling the sizeof expressions where
-// we test the handler type requirements. We'll disable checking of handler type
-// requirements for those compilers, but otherwise enable it by default.
-#if !defined(BOOST_ASIO_DISABLE_HANDLER_TYPE_REQUIREMENTS)
-# if !defined(__GNUC__) || (__GNUC__ >= 4)
-#  define BOOST_ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS 1
-# endif // !defined(__GNUC__) || (__GNUC__ >= 4)
-#endif // !defined(BOOST_ASIO_DISABLE_HANDLER_TYPE_REQUIREMENTS)
-
-// With C++0x we can use a combination of enhanced SFINAE and static_assert to
-// generate better template error messages. As this technique is not yet widely
-// portable, we'll only enable it for tested compilers.
-#if !defined(BOOST_ASIO_DISABLE_HANDLER_TYPE_REQUIREMENTS_ASSERT)
-# if defined(__GNUC__)
-#  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 (_MSC_VER >= 1600)
-#   define BOOST_ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS_ASSERT 1
-#  endif // (_MSC_VER >= 1600)
-# endif // defined(BOOST_MSVC)
-#endif // !defined(BOOST_ASIO_DISABLE_HANDLER_TYPE_REQUIREMENTS)
-
-namespace boost {
-namespace asio {
-namespace detail {
-
-#if defined(BOOST_ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS)
-
-# if defined(BOOST_ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS_ASSERT)
-
-template <typename Handler>
-auto zero_arg_handler_test(Handler h, void*)
-  -> decltype(
-    sizeof(Handler(static_cast<const Handler&>(h))),
-    ((h)()),
-    char(0));
-
-template <typename Handler>
-char (&zero_arg_handler_test(Handler, ...))[2];
-
-template <typename Handler, typename Arg1>
-auto one_arg_handler_test(Handler h, Arg1* a1)
-  -> decltype(
-    sizeof(Handler(static_cast<const Handler&>(h))),
-    ((h)(*a1)),
-    char(0));
-
-template <typename Handler>
-char (&one_arg_handler_test(Handler h, ...))[2];
-
-template <typename Handler, typename Arg1, typename Arg2>
-auto two_arg_handler_test(Handler h, Arg1* a1, Arg2* a2)
-  -> decltype(
-    sizeof(Handler(static_cast<const Handler&>(h))),
-    ((h)(*a1, *a2)),
-    char(0));
-
-template <typename Handler>
-char (&two_arg_handler_test(Handler, ...))[2];
-
-#  define BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT(expr, msg) \
-     static_assert(expr, msg);
-
-# else // defined(BOOST_ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS_ASSERT)
-
-#  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(T);
-template <typename T> char argbyv(T);
-
-template <int>
-struct handler_type_requirements
-{
-};
-
-#define BOOST_ASIO_COMPLETION_HANDLER_CHECK( \
-    handler_type, handler) \
-  \
-  BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
-      sizeof(boost::asio::detail::zero_arg_handler_test( \
-          handler, 0)) == 1, \
-      "CompletionHandler type requirements not met") \
-  \
-  typedef boost::asio::detail::handler_type_requirements< \
-      sizeof( \
-        boost::asio::detail::argbyv( \
-          boost::asio::detail::clvref(handler))) + \
-      sizeof( \
-        boost::asio::detail::lvref(handler)(), \
-        char(0))>
-
-#define BOOST_ASIO_READ_HANDLER_CHECK( \
-    handler_type, handler) \
-  \
-  BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
-      sizeof(boost::asio::detail::two_arg_handler_test( \
-          handler, \
-          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))) + \
-      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))>
-
-#define BOOST_ASIO_WRITE_HANDLER_CHECK( \
-    handler_type, handler) \
-  \
-  BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
-      sizeof(boost::asio::detail::two_arg_handler_test( \
-          handler, \
-          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))) + \
-      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))>
-
-#define BOOST_ASIO_ACCEPT_HANDLER_CHECK( \
-    handler_type, handler) \
-  \
-  BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
-      sizeof(boost::asio::detail::one_arg_handler_test( \
-          handler, \
-          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))) + \
-      sizeof( \
-        boost::asio::detail::lvref(handler)( \
-          boost::asio::detail::lvref<const boost::system::error_code>()), \
-        char(0))>
-
-#define BOOST_ASIO_CONNECT_HANDLER_CHECK( \
-    handler_type, handler) \
-  \
-  BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
-      sizeof(boost::asio::detail::one_arg_handler_test( \
-          handler, \
-          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))) + \
-      sizeof( \
-        boost::asio::detail::lvref(handler)( \
-          boost::asio::detail::lvref<const boost::system::error_code>()), \
-        char(0))>
-
-#define BOOST_ASIO_COMPOSED_CONNECT_HANDLER_CHECK( \
-    handler_type, handler, iter_type) \
-  \
-  BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
-      sizeof(boost::asio::detail::two_arg_handler_test( \
-          handler, \
-          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))) + \
-      sizeof( \
-        boost::asio::detail::lvref(handler)( \
-          boost::asio::detail::lvref<const boost::system::error_code>(), \
-          boost::asio::detail::lvref<const iter_type>()), \
-        char(0))>
-
-#define BOOST_ASIO_RESOLVE_HANDLER_CHECK( \
-    handler_type, handler, iter_type) \
-  \
-  BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
-      sizeof(boost::asio::detail::two_arg_handler_test( \
-          handler, \
-          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))) + \
-      sizeof( \
-        boost::asio::detail::lvref(handler)( \
-          boost::asio::detail::lvref<const boost::system::error_code>(), \
-          boost::asio::detail::lvref<const iter_type>()), \
-        char(0))>
-
-#define BOOST_ASIO_WAIT_HANDLER_CHECK( \
-    handler_type, handler) \
-  \
-  BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
-      sizeof(boost::asio::detail::one_arg_handler_test( \
-          handler, \
-          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))) + \
-      sizeof( \
-        boost::asio::detail::lvref(handler)( \
-          boost::asio::detail::lvref<const boost::system::error_code>()), \
-        char(0))>
-
-#define BOOST_ASIO_SIGNAL_HANDLER_CHECK( \
-    handler_type, handler) \
-  \
-  BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
-      sizeof(boost::asio::detail::two_arg_handler_test( \
-          handler, \
-          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))) + \
-      sizeof( \
-        boost::asio::detail::lvref(handler)( \
-          boost::asio::detail::lvref<const boost::system::error_code>(), \
-          boost::asio::detail::lvref<const int>()), \
-        char(0))>
-
-#define BOOST_ASIO_HANDSHAKE_HANDLER_CHECK( \
-    handler_type, handler) \
-  \
-  BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
-      sizeof(boost::asio::detail::one_arg_handler_test( \
-          handler, \
-          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))) + \
-      sizeof( \
-        boost::asio::detail::lvref(handler)( \
-          boost::asio::detail::lvref<const boost::system::error_code>()), \
-        char(0))>
-
-#define BOOST_ASIO_SHUTDOWN_HANDLER_CHECK( \
-    handler_type, handler) \
-  \
-  BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \
-      sizeof(boost::asio::detail::one_arg_handler_test( \
-          handler, \
-          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))) + \
-      sizeof( \
-        boost::asio::detail::lvref(handler)( \
-          boost::asio::detail::lvref<const boost::system::error_code>()), \
-        char(0))>
-
-#else // !defined(BOOST_ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS)
-
-#define BOOST_ASIO_COMPLETION_HANDLER_CHECK( \
-    handler_type, handler) \
-  typedef int
-
-#define BOOST_ASIO_READ_HANDLER_CHECK( \
-    handler_type, handler) \
-  typedef int
-
-#define BOOST_ASIO_WRITE_HANDLER_CHECK( \
-    handler_type, handler) \
-  typedef int
-
-#define BOOST_ASIO_ACCEPT_HANDLER_CHECK( \
-    handler_type, handler) \
-  typedef int
-
-#define BOOST_ASIO_CONNECT_HANDLER_CHECK( \
-    handler_type, handler) \
-  typedef int
-
-#define BOOST_ASIO_COMPOSED_CONNECT_HANDLER_CHECK( \
-    handler_type, handler, iter_type) \
-  typedef int
-
-#define BOOST_ASIO_RESOLVE_HANDLER_CHECK( \
-    handler_type, handler, iter_type) \
-  typedef int
-
-#define BOOST_ASIO_WAIT_HANDLER_CHECK( \
-    handler_type, handler) \
-  typedef int
-
-#define BOOST_ASIO_SIGNAL_HANDLER_CHECK( \
-    handler_type, handler) \
-  typedef int
-
-#define BOOST_ASIO_HANDSHAKE_HANDLER_CHECK( \
-    handler_type, handler) \
-  typedef int
-
-#define BOOST_ASIO_SHUTDOWN_HANDLER_CHECK( \
-    handler_type, handler) \
-  typedef int
-
-#endif // !defined(BOOST_ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS)
-
-} // namespace detail
-} // namespace asio
-} // namespace boost
-
-#endif // BOOST_ASIO_DETAIL_HANDLER_TYPE_REQUIREMENTS_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/hash_map.hpp b/3rdParty/Boost/src/boost/asio/detail/hash_map.hpp
index 339ab9d..4f4eed3 100644
--- a/3rdParty/Boost/src/boost/asio/detail/hash_map.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/hash_map.hpp
@@ -1,54 +1,54 @@
 //
 // detail/hash_map.hpp
 // ~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_HASH_MAP_HPP
 #define BOOST_ASIO_DETAIL_HASH_MAP_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/assert.hpp>
+#include <cassert>
 #include <list>
 #include <utility>
 #include <boost/asio/detail/noncopyable.hpp>
 
 #if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
 # include <boost/asio/detail/socket_types.hpp>
 #endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 inline std::size_t calculate_hash_value(int i)
 {
   return static_cast<std::size_t>(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__)
 inline std::size_t calculate_hash_value(SOCKET s)
 {
   return static_cast<std::size_t>(s);
 }
 #endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
 
 // Note: assumes K and V are POD types.
 template <typename K, typename V>
 class hash_map
@@ -85,213 +85,213 @@ public:
   }
 
   // Get an iterator for the beginning of the map.
   const_iterator begin() const
   {
     return values_.begin();
   }
 
   // Get an iterator for the end of the map.
   iterator end()
   {
     return values_.end();
   }
 
   // Get an iterator for the end of the map.
   const_iterator end() const
   {
     return values_.end();
   }
 
   // Check whether the map is empty.
   bool empty() const
   {
     return values_.empty();
   }
 
   // Find an entry in the map.
   iterator find(const K& k)
   {
     if (num_buckets_)
     {
       size_t bucket = calculate_hash_value(k) % num_buckets_;
       iterator it = buckets_[bucket].first;
       if (it == values_.end())
         return values_.end();
-      iterator end_it = buckets_[bucket].last;
-      ++end_it;
-      while (it != end_it)
+      iterator end = buckets_[bucket].last;
+      ++end;
+      while (it != end)
       {
         if (it->first == k)
           return it;
         ++it;
       }
     }
     return values_.end();
   }
 
   // Find an entry in the map.
   const_iterator find(const K& k) const
   {
     if (num_buckets_)
     {
       size_t bucket = calculate_hash_value(k) % num_buckets_;
       const_iterator it = buckets_[bucket].first;
       if (it == values_.end())
         return it;
-      const_iterator end_it = buckets_[bucket].last;
-      ++end_it;
-      while (it != end_it)
+      const_iterator end = buckets_[bucket].last;
+      ++end;
+      while (it != end)
       {
         if (it->first == k)
           return it;
         ++it;
       }
     }
     return values_.end();
   }
 
   // Insert a new entry into the map.
   std::pair<iterator, bool> insert(const value_type& v)
   {
     if (size_ + 1 >= num_buckets_)
       rehash(hash_size(size_ + 1));
     size_t bucket = calculate_hash_value(v.first) % num_buckets_;
     iterator it = buckets_[bucket].first;
     if (it == values_.end())
     {
       buckets_[bucket].first = buckets_[bucket].last =
         values_insert(values_.end(), v);
       ++size_;
       return std::pair<iterator, bool>(buckets_[bucket].last, true);
     }
-    iterator end_it = buckets_[bucket].last;
-    ++end_it;
-    while (it != end_it)
+    iterator end = buckets_[bucket].last;
+    ++end;
+    while (it != end)
     {
       if (it->first == v.first)
         return std::pair<iterator, bool>(it, false);
       ++it;
     }
-    buckets_[bucket].last = values_insert(end_it, v);
+    buckets_[bucket].last = values_insert(end, v);
     ++size_;
     return std::pair<iterator, bool>(buckets_[bucket].last, true);
   }
 
   // Erase an entry from the map.
   void erase(iterator it)
   {
-    BOOST_ASSERT(it != values_.end());
+    assert(it != values_.end());
 
     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();
     else if (is_first)
       ++buckets_[bucket].first;
     else if (is_last)
       --buckets_[bucket].last;
 
     values_erase(it);
     --size_;
   }
 
   // Erase a key from the map.
   void erase(const K& k)
   {
     iterator it = find(k);
     if (it != values_.end())
       erase(it);
   }
 
   // Remove all entries from the map.
   void clear()
   {
     // Clear the values.
     values_.clear();
     size_ = 0;
 
     // Initialise all buckets to empty.
-    iterator end_it = values_.end();
+    iterator end = values_.end();
     for (size_t i = 0; i < num_buckets_; ++i)
-      buckets_[i].first = buckets_[i].last = end_it;
+      buckets_[i].first = buckets_[i].last = end;
   }
 
 private:
   // Calculate the hash size for the specified number of elements.
   static std::size_t hash_size(std::size_t num_elems)
   {
     static std::size_t sizes[] =
     {
 #if defined(BOOST_ASIO_HASH_MAP_BUCKETS)
       BOOST_ASIO_HASH_MAP_BUCKETS
 #else // BOOST_ASIO_HASH_MAP_BUCKETS
       3, 13, 23, 53, 97, 193, 389, 769, 1543, 3079, 6151, 12289, 24593,
       49157, 98317, 196613, 393241, 786433, 1572869, 3145739, 6291469,
       12582917, 25165843
 #endif // BOOST_ASIO_HASH_MAP_BUCKETS
     };
     const std::size_t nth_size = sizeof(sizes) / sizeof(std::size_t) - 1;
     for (std::size_t i = 0; i < nth_size; ++i)
       if (num_elems < sizes[i])
         return sizes[i];
     return sizes[nth_size];
   }
 
   // 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;
 
-    iterator end_iter = values_.end();
+    iterator end = values_.end();
 
     // Update number of buckets and initialise all buckets to empty.
     bucket_type* tmp = new bucket_type[num_buckets_];
     delete[] buckets_;
     buckets_ = tmp;
     for (std::size_t i = 0; i < num_buckets_; ++i)
-      buckets_[i].first = buckets_[i].last = end_iter;
+      buckets_[i].first = buckets_[i].last = end;
 
     // Put all values back into the hash.
     iterator iter = values_.begin();
-    while (iter != end_iter)
+    while (iter != end)
     {
       std::size_t bucket = calculate_hash_value(iter->first) % num_buckets_;
-      if (buckets_[bucket].last == end_iter)
+      if (buckets_[bucket].last == end)
       {
         buckets_[bucket].first = buckets_[bucket].last = iter++;
       }
       else if (++buckets_[bucket].last == iter)
       {
         ++iter;
       }
       else
       {
         values_.splice(buckets_[bucket].last, values_, iter++);
         --buckets_[bucket].last;
       }
     }
   }
 
   // Insert an element into the values list by splicing from the spares list,
   // if a spare is available, and otherwise by inserting a new element.
   iterator values_insert(iterator it, const value_type& v)
   {
     if (spares_.empty())
     {
       return values_.insert(it, v);
     }
     else
     {
       spares_.front() = v;
       values_.splice(it, spares_, spares_.begin());
       return --it;
     }
   }
 
   // Erase an element from the values list by splicing it to the spares list.
   void values_erase(iterator it)
   {
     *it = value_type();
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..9a2bb3b 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/descriptor_ops.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/descriptor_ops.ipp
@@ -1,241 +1,176 @@
 //
 // detail/impl/descriptor_ops.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_IMPL_DESCRIPTOR_OPS_IPP
 #define BOOST_ASIO_DETAIL_IMPL_DESCRIPTOR_OPS_IPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #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__)
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 namespace descriptor_ops {
 
 int open(const char* path, int flags, boost::system::error_code& ec)
 {
   errno = 0;
   int result = error_wrapper(::open(path, flags), ec);
   if (result >= 0)
     ec = boost::system::error_code();
   return result;
 }
 
 int close(int d, state_type& state, boost::system::error_code& ec)
 {
   int result = 0;
   if (d != -1)
   {
-    errno = 0;
-    result = error_wrapper(::close(d), ec);
-
-    if (result != 0
-        && (ec == boost::asio::error::would_block
-          || ec == boost::asio::error::try_again))
+    if (state & internal_non_blocking)
     {
-      // 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(__SYMBIAN32__)
       int flags = ::fcntl(d, F_GETFL, 0);
       if (flags >= 0)
         ::fcntl(d, F_SETFL, flags & ~O_NONBLOCK);
 #else // defined(__SYMBIAN32__)
       ioctl_arg_type arg = 0;
       ::ioctl(d, FIONBIO, &arg);
 #endif // defined(__SYMBIAN32__)
-      state &= ~non_blocking;
-
-      errno = 0;
-      result = error_wrapper(::close(d), ec);
+      state &= ~internal_non_blocking;
     }
-  }
-
-  if (result == 0)
-    ec = boost::system::error_code();
-  return result;
-}
-
-bool set_user_non_blocking(int d, state_type& state,
-    bool value, boost::system::error_code& ec)
-{
-  if (d == -1)
-  {
-    ec = boost::asio::error::bad_descriptor;
-    return false;
-  }
 
-  errno = 0;
-#if defined(__SYMBIAN32__)
-  int result = error_wrapper(::fcntl(d, F_GETFL, 0), ec);
-  if (result >= 0)
-  {
     errno = 0;
-    int flag = (value ? (result | O_NONBLOCK) : (result & ~O_NONBLOCK));
-    result = error_wrapper(::fcntl(d, F_SETFL, flag), ec);
+    result = error_wrapper(::close(d), ec);
   }
-#else // defined(__SYMBIAN32__)
-  ioctl_arg_type arg = (value ? 1 : 0);
-  int result = error_wrapper(::ioctl(d, FIONBIO, &arg), ec);
-#endif // defined(__SYMBIAN32__)
 
-  if (result >= 0)
-  {
+  if (result == 0)
     ec = boost::system::error_code();
-    if (value)
-      state |= user_set_non_blocking;
-    else
-    {
-      // Clearing the user-set non-blocking mode always overrides any
-      // internally-set non-blocking flag. Any subsequent asynchronous
-      // operations will need to re-enable non-blocking I/O.
-      state &= ~(user_set_non_blocking | internal_non_blocking);
-    }
-    return true;
-  }
-
-  return false;
+  return result;
 }
 
-bool set_internal_non_blocking(int d, state_type& state,
-    bool value, boost::system::error_code& ec)
+bool set_internal_non_blocking(int d,
+    state_type& state, boost::system::error_code& ec)
 {
   if (d == -1)
   {
     ec = boost::asio::error::bad_descriptor;
     return false;
   }
 
-  if (!value && (state & user_set_non_blocking))
-  {
-    // It does not make sense to clear the internal non-blocking flag if the
-    // user still wants non-blocking behaviour. Return an error and let the
-    // caller figure out whether to update the user-set non-blocking flag.
-    ec = boost::asio::error::invalid_argument;
-    return false;
-  }
-
   errno = 0;
 #if defined(__SYMBIAN32__)
   int result = error_wrapper(::fcntl(d, F_GETFL, 0), ec);
   if (result >= 0)
   {
     errno = 0;
-    int flag = (value ? (result | O_NONBLOCK) : (result & ~O_NONBLOCK));
-    result = error_wrapper(::fcntl(d, F_SETFL, flag), ec);
+    result = error_wrapper(::fcntl(d, F_SETFL, result | O_NONBLOCK), ec);
   }
 #else // defined(__SYMBIAN32__)
-  ioctl_arg_type arg = (value ? 1 : 0);
+  ioctl_arg_type arg = 1;
   int result = error_wrapper(::ioctl(d, FIONBIO, &arg), ec);
 #endif // defined(__SYMBIAN32__)
 
   if (result >= 0)
   {
     ec = boost::system::error_code();
-    if (value)
-      state |= internal_non_blocking;
-    else
-      state &= ~internal_non_blocking;
+    state |= internal_non_blocking;
     return true;
   }
 
   return false;
 }
 
 std::size_t sync_read(int d, state_type state, buf* bufs,
     std::size_t count, bool all_empty, boost::system::error_code& ec)
 {
   if (d == -1)
   {
     ec = boost::asio::error::bad_descriptor;
     return 0;
   }
 
   // A request to read 0 bytes on a stream is a no-op.
   if (all_empty)
   {
     ec = boost::system::error_code();
     return 0;
   }
 
   // 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);
 
     // Check if operation succeeded.
     if (bytes > 0)
       return bytes;
 
     // Check for EOF.
     if (bytes == 0)
     {
       ec = boost::asio::error::eof;
       return 0;
     }
 
     // Operation failed.
     if ((state & user_set_non_blocking)
         || (ec != boost::asio::error::would_block
           && ec != boost::asio::error::try_again))
       return 0;
 
     // Wait for descriptor to become ready.
-    if (descriptor_ops::poll_read(d, 0, ec) < 0)
+    if (descriptor_ops::poll_read(d, ec) < 0)
       return 0;
   }
 }
 
 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);
 
     // Check for end of stream.
     if (bytes == 0)
     {
       ec = boost::asio::error::eof;
       return true;
     }
 
     // Retry operation if interrupted by signal.
     if (ec == boost::asio::error::interrupted)
       continue;
 
     // Check if we need to run the operation again.
     if (ec == boost::asio::error::would_block
         || ec == boost::asio::error::try_again)
       return false;
 
     // Operation is complete.
     if (bytes > 0)
     {
       ec = boost::system::error_code();
       bytes_transferred = bytes;
     }
@@ -248,71 +183,71 @@ bool non_blocking_read(int d, buf* bufs, std::size_t count,
 
 std::size_t sync_write(int d, state_type state, const buf* bufs,
     std::size_t count, bool all_empty, boost::system::error_code& ec)
 {
   if (d == -1)
   {
     ec = boost::asio::error::bad_descriptor;
     return 0;
   }
 
   // A request to write 0 bytes on a stream is a no-op.
   if (all_empty)
   {
     ec = boost::system::error_code();
     return 0;
   }
 
   // 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);
 
     // Check if operation succeeded.
     if (bytes > 0)
       return bytes;
 
     // Operation failed.
     if ((state & user_set_non_blocking)
         || (ec != boost::asio::error::would_block
           && ec != boost::asio::error::try_again))
       return 0;
 
     // Wait for descriptor to become ready.
-    if (descriptor_ops::poll_write(d, 0, ec) < 0)
+    if (descriptor_ops::poll_write(d, ec) < 0)
       return 0;
   }
 }
 
 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);
 
     // Retry operation if interrupted by signal.
     if (ec == boost::asio::error::interrupted)
       continue;
 
     // Check if we need to run the operation again.
     if (ec == boost::asio::error::would_block
         || ec == boost::asio::error::try_again)
       return false;
 
     // Operation is complete.
     if (bytes >= 0)
     {
       ec = boost::system::error_code();
       bytes_transferred = bytes;
     }
     else
       bytes_transferred = 0;
 
     return true;
   }
 }
 
@@ -355,91 +290,83 @@ int ioctl(int d, state_type& state, long cmd,
   }
 
   return result;
 }
 
 int fcntl(int d, long cmd, boost::system::error_code& ec)
 {
   if (d == -1)
   {
     ec = boost::asio::error::bad_descriptor;
     return -1;
   }
 
   errno = 0;
   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)
 {
   if (d == -1)
   {
     ec = boost::asio::error::bad_descriptor;
     return -1;
   }
 
   errno = 0;
   int result = error_wrapper(::fcntl(d, cmd, arg), ec);
   if (result != -1)
     ec = boost::system::error_code();
   return result;
 }
 
-int poll_read(int d, state_type state, boost::system::error_code& ec)
+int poll_read(int d, boost::system::error_code& ec)
 {
   if (d == -1)
   {
     ec = boost::asio::error::bad_descriptor;
     return -1;
   }
 
   pollfd fds;
   fds.fd = d;
   fds.events = POLLIN;
   fds.revents = 0;
-  int timeout = (state & user_set_non_blocking) ? 0 : -1;
   errno = 0;
-  int result = error_wrapper(::poll(&fds, 1, timeout), ec);
-  if (result == 0)
-    ec = (state & user_set_non_blocking)
-      ? boost::asio::error::would_block : boost::system::error_code();
-  else if (result > 0)
+  int result = error_wrapper(::poll(&fds, 1, -1), ec);
+  if (result >= 0)
     ec = boost::system::error_code();
   return result;
 }
 
-int poll_write(int d, state_type state, boost::system::error_code& ec)
+int poll_write(int d, boost::system::error_code& ec)
 {
   if (d == -1)
   {
     ec = boost::asio::error::bad_descriptor;
     return -1;
   }
 
   pollfd fds;
   fds.fd = d;
   fds.events = POLLOUT;
   fds.revents = 0;
-  int timeout = (state & user_set_non_blocking) ? 0 : -1;
   errno = 0;
-  int result = error_wrapper(::poll(&fds, 1, timeout), ec);
-  if (result == 0)
-    ec = (state & user_set_non_blocking)
-      ? boost::asio::error::would_block : boost::system::error_code();
-  else if (result > 0)
+  int result = error_wrapper(::poll(&fds, 1, -1), ec);
+  if (result >= 0)
     ec = boost::system::error_code();
   return result;
 }
 
 } // namespace descriptor_ops
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // !defined(BOOST_WINDOWS) && !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..a6b7078 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,80 +1,79 @@
 //
 // detail/impl/dev_poll_reactor.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_IMPL_DEV_POLL_REACTOR_HPP
 #define BOOST_ASIO_DETAIL_IMPL_DEV_POLL_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_HAS_DEV_POLL)
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 template <typename Time_Traits>
 void dev_poll_reactor::add_timer_queue(timer_queue<Time_Traits>& queue)
 {
   do_add_timer_queue(queue);
 }
 
 template <typename Time_Traits>
 void dev_poll_reactor::remove_timer_queue(timer_queue<Time_Traits>& queue)
 {
   do_remove_timer_queue(queue);
 }
 
 template <typename Time_Traits>
 void dev_poll_reactor::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)
+    typename timer_queue<Time_Traits>::per_timer_data& timer, timer_op* op)
 {
   boost::asio::detail::mutex::scoped_lock lock(mutex_);
 
   if (shutdown_)
   {
     io_service_.post_immediate_completion(op);
     return;
   }
 
   bool earliest = queue.enqueue_timer(time, timer, op);
   io_service_.work_started();
   if (earliest)
     interrupter_.interrupt();
 }
 
 template <typename Time_Traits>
 std::size_t dev_poll_reactor::cancel_timer(timer_queue<Time_Traits>& queue,
-    typename timer_queue<Time_Traits>::per_timer_data& timer,
-    std::size_t max_cancelled)
+    typename timer_queue<Time_Traits>::per_timer_data& timer)
 {
   boost::asio::detail::mutex::scoped_lock lock(mutex_);
   op_queue<operation> ops;
-  std::size_t n = queue.cancel_timer(timer, ops, max_cancelled);
+  std::size_t n = queue.cancel_timer(timer, ops);
   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_HAS_DEV_POLL)
 
 #endif // BOOST_ASIO_DETAIL_IMPL_DEV_POLL_REACTOR_HPP
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..b9d5e61 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,381 +1,274 @@
 //
 // detail/impl/dev_poll_reactor.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_IMPL_DEV_POLL_REACTOR_IPP
 #define BOOST_ASIO_DETAIL_IMPL_DEV_POLL_REACTOR_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_HAS_DEV_POLL)
 
-#include <boost/assert.hpp>
 #include <boost/asio/detail/dev_poll_reactor.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 {
 
 dev_poll_reactor::dev_poll_reactor(boost::asio::io_service& io_service)
   : boost::asio::detail::service_base<dev_poll_reactor>(io_service),
     io_service_(use_service<io_service_impl>(io_service)),
     mutex_(),
     dev_poll_fd_(do_dev_poll_create()),
     interrupter_(),
     shutdown_(false)
 {
   // Add the interrupter's descriptor to /dev/poll.
-  ::pollfd ev = { 0, 0, 0 };
+  ::pollfd ev = { 0 };
   ev.fd = interrupter_.read_descriptor();
   ev.events = POLLIN | POLLERR;
   ev.revents = 0;
   ::write(dev_poll_fd_, &ev, sizeof(ev));
 }
 
 dev_poll_reactor::~dev_poll_reactor()
 {
   shutdown_service();
   ::close(dev_poll_fd_);
 }
 
 void dev_poll_reactor::shutdown_service()
 {
   boost::asio::detail::mutex::scoped_lock lock(mutex_);
   shutdown_ = true;
   lock.unlock();
 
   op_queue<operation> ops;
 
   for (int i = 0; i < max_ops; ++i)
     op_queue_[i].get_all_operations(ops);
 
   timer_queues_.get_all_timers(ops);
-
-  io_service_.abandon_operations(ops);
 } 
 
-// Helper class to re-register all descriptors with /dev/poll.
-class dev_poll_reactor::fork_helper
-{
-public:
-  fork_helper(dev_poll_reactor* reactor, short events)
-    : reactor_(reactor), events_(events)
-  {
-  }
-
-  bool set(int descriptor)
-  {
-    ::pollfd& ev = reactor_->add_pending_event_change(descriptor);
-    ev.events = events_;
-    return true;
-  }
-
-private:
-  dev_poll_reactor* reactor_;
-  short events_;
-};
-
-void dev_poll_reactor::fork_service(boost::asio::io_service::fork_event fork_ev)
-{
-  if (fork_ev == boost::asio::io_service::fork_child)
-  {
-    detail::mutex::scoped_lock lock(mutex_);
-
-    if (dev_poll_fd_ != -1)
-      ::close(dev_poll_fd_);
-    dev_poll_fd_ = -1;
-    dev_poll_fd_ = do_dev_poll_create();
-
-    interrupter_.recreate();
-
-    // Add the interrupter's descriptor to /dev/poll.
-    ::pollfd ev = { 0, 0, 0 };
-    ev.fd = interrupter_.read_descriptor();
-    ev.events = POLLIN | POLLERR;
-    ev.revents = 0;
-    ::write(dev_poll_fd_, &ev, sizeof(ev));
-
-    // Re-register all descriptors with /dev/poll. The changes will be written
-    // to the /dev/poll descriptor the next time the reactor is run.
-    op_queue<operation> ops;
-    fork_helper read_op_helper(this, POLLERR | POLLHUP | POLLIN);
-    op_queue_[read_op].get_descriptors(read_op_helper, ops);
-    fork_helper write_op_helper(this, POLLERR | POLLHUP | POLLOUT);
-    op_queue_[write_op].get_descriptors(write_op_helper, ops);
-    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());
-  }
-}
-
 void dev_poll_reactor::init_task()
 {
   io_service_.init_task();
 }
 
 int dev_poll_reactor::register_descriptor(socket_type, per_descriptor_data&)
 {
   return 0;
 }
 
-int dev_poll_reactor::register_internal_descriptor(int op_type,
-    socket_type descriptor, per_descriptor_data&, reactor_op* op)
-{
-  boost::asio::detail::mutex::scoped_lock lock(mutex_);
-
-  op_queue_[op_type].enqueue_operation(descriptor, op);
-  ::pollfd& ev = add_pending_event_change(descriptor);
-  ev.events = POLLERR | POLLHUP;
-  switch (op_type)
-  {
-  case read_op: ev.events |= POLLIN; break;
-  case write_op: ev.events |= POLLOUT; break;
-  case except_op: ev.events |= POLLPRI; break;
-  default: break;
-  }
-  interrupter_.interrupt();
-
-  return 0;
-}
-
-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)
 {
   boost::asio::detail::mutex::scoped_lock lock(mutex_);
 
   if (shutdown_)
   {
     post_immediate_completion(op);
     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);
           return;
         }
       }
     }
   }
 
   bool first = op_queue_[op_type].enqueue_operation(descriptor, op);
   io_service_.work_started();
   if (first)
   {
     ::pollfd& ev = add_pending_event_change(descriptor);
     ev.events = POLLERR | POLLHUP;
     if (op_type == read_op
         || op_queue_[read_op].has_operation(descriptor))
       ev.events |= POLLIN;
     if (op_type == write_op
         || op_queue_[write_op].has_operation(descriptor))
       ev.events |= POLLOUT;
     if (op_type == except_op
         || op_queue_[except_op].has_operation(descriptor))
       ev.events |= POLLPRI;
     interrupter_.interrupt();
   }
 }
 
 void dev_poll_reactor::cancel_ops(socket_type descriptor,
     dev_poll_reactor::per_descriptor_data&)
 {
   boost::asio::detail::mutex::scoped_lock lock(mutex_);
   cancel_ops_unlocked(descriptor, boost::asio::error::operation_aborted);
 }
 
-void dev_poll_reactor::deregister_descriptor(socket_type descriptor,
-    dev_poll_reactor::per_descriptor_data&, bool)
+void dev_poll_reactor::close_descriptor(socket_type descriptor,
+    dev_poll_reactor::per_descriptor_data&)
 {
   boost::asio::detail::mutex::scoped_lock lock(mutex_);
 
   // Remove the descriptor from /dev/poll.
   ::pollfd& ev = add_pending_event_change(descriptor);
   ev.events = POLLREMOVE;
   interrupter_.interrupt();
 
   // Cancel any outstanding operations associated with the descriptor.
   cancel_ops_unlocked(descriptor, boost::asio::error::operation_aborted);
 }
 
-void dev_poll_reactor::deregister_internal_descriptor(
-    socket_type descriptor, dev_poll_reactor::per_descriptor_data&)
-{
-  boost::asio::detail::mutex::scoped_lock lock(mutex_);
-
-  // Remove the descriptor from /dev/poll. Since this function is only called
-  // during a fork, we can apply the change immediately.
-  ::pollfd ev = { 0, 0, 0 };
-  ev.fd = descriptor;
-  ev.events = POLLREMOVE;
-  ev.revents = 0;
-  ::write(dev_poll_fd_, &ev, sizeof(ev));
-
-  // Destroy all operations associated with the descriptor.
-  op_queue<operation> ops;
-  boost::system::error_code ec;
-  for (int i = 0; i < max_ops; ++i)
-    op_queue_[i].cancel_operations(descriptor, ops, ec);
-}
-
 void dev_poll_reactor::run(bool block, op_queue<operation>& ops)
 {
   boost::asio::detail::mutex::scoped_lock lock(mutex_);
 
   // We can return immediately if there's no work to do and the reactor is
   // not supposed to block.
   if (!block && op_queue_[read_op].empty() && op_queue_[write_op].empty()
       && op_queue_[except_op].empty() && timer_queues_.all_empty())
     return;
 
   // Write the pending event registration changes to the /dev/poll descriptor.
   std::size_t events_size = sizeof(::pollfd) * pending_event_changes_.size();
   if (events_size > 0)
   {
     errno = 0;
     int result = ::write(dev_poll_fd_,
         &pending_event_changes_[0], events_size);
     if (result != static_cast<int>(events_size))
     {
       boost::system::error_code ec = boost::system::error_code(
           errno, boost::asio::error::get_system_category());
       for (std::size_t i = 0; i < pending_event_changes_.size(); ++i)
       {
         int descriptor = pending_event_changes_[i].fd;
         for (int j = 0; j < max_ops; ++j)
           op_queue_[j].cancel_operations(descriptor, ops, ec);
       }
     }
     pending_event_changes_.clear();
     pending_event_change_index_.clear();
   }
 
   int timeout = block ? get_timeout() : 0;
   lock.unlock();
 
   // Block on the /dev/poll descriptor.
-  ::pollfd events[128] = { { 0, 0, 0 } };
-  ::dvpoll dp = { 0, 0, 0 };
+  ::pollfd events[128] = { { 0 } };
+  ::dvpoll dp = { 0 };
   dp.dp_fds = events;
   dp.dp_nfds = 128;
   dp.dp_timeout = timeout;
   int num_events = ::ioctl(dev_poll_fd_, DP_POLL, &dp);
 
   lock.lock();
 
   // Dispatch the waiting events.
   for (int i = 0; i < num_events; ++i)
   {
     int descriptor = events[i].fd;
     if (descriptor == interrupter_.read_descriptor())
     {
       interrupter_.reset();
     }
     else
     {
       bool more_reads = false;
       bool more_writes = false;
       bool more_except = false;
 
       // Exception operations must be processed first to ensure that any
       // out-of-band data is read before normal data.
       if (events[i].events & (POLLPRI | POLLERR | POLLHUP))
         more_except =
           op_queue_[except_op].perform_operations(descriptor, ops);
       else
         more_except = op_queue_[except_op].has_operation(descriptor);
 
       if (events[i].events & (POLLIN | POLLERR | POLLHUP))
         more_reads = op_queue_[read_op].perform_operations(descriptor, ops);
       else
         more_reads = op_queue_[read_op].has_operation(descriptor);
 
       if (events[i].events & (POLLOUT | POLLERR | POLLHUP))
         more_writes = op_queue_[write_op].perform_operations(descriptor, ops);
       else
         more_writes = op_queue_[write_op].has_operation(descriptor);
 
       if ((events[i].events & (POLLERR | POLLHUP)) != 0
             && !more_except && !more_reads && !more_writes)
       {
         // If we have an event and no operations associated with the
         // descriptor then we need to delete the descriptor from /dev/poll.
         // The poll operation can produce POLLHUP or POLLERR events when there
         // is no operation pending, so if we do not remove the descriptor we
         // can end up in a tight polling loop.
-        ::pollfd ev = { 0, 0, 0 };
+        ::pollfd ev = { 0 };
         ev.fd = descriptor;
         ev.events = POLLREMOVE;
         ev.revents = 0;
         ::write(dev_poll_fd_, &ev, sizeof(ev));
       }
       else
       {
-        ::pollfd ev = { 0, 0, 0 };
+        ::pollfd ev = { 0 };
         ev.fd = descriptor;
         ev.events = POLLERR | POLLHUP;
         if (more_reads)
           ev.events |= POLLIN;
         if (more_writes)
           ev.events |= POLLOUT;
         if (more_except)
           ev.events |= POLLPRI;
         ev.revents = 0;
         int result = ::write(dev_poll_fd_, &ev, sizeof(ev));
         if (result != sizeof(ev))
         {
           boost::system::error_code ec(errno,
               boost::asio::error::get_system_category());
           for (int j = 0; j < max_ops; ++j)
             op_queue_[j].cancel_operations(descriptor, ops, ec);
         }
       }
     }
   }
   timer_queues_.get_ready_timers(ops);
 }
 
 void dev_poll_reactor::interrupt()
 {
   interrupter_.interrupt();
 }
 
 int dev_poll_reactor::do_dev_poll_create()
 {
   int fd = ::open("/dev/poll", O_RDWR);
   if (fd == -1)
   {
     boost::system::error_code ec(errno,
         boost::asio::error::get_system_category());
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..0339cfd 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/epoll_reactor.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/epoll_reactor.hpp
@@ -1,78 +1,77 @@
 //
 // detail/impl/epoll_reactor.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_IMPL_EPOLL_REACTOR_HPP
 #define BOOST_ASIO_DETAIL_IMPL_EPOLL_REACTOR_HPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #if defined(BOOST_ASIO_HAS_EPOLL)
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 template <typename Time_Traits>
 void epoll_reactor::add_timer_queue(timer_queue<Time_Traits>& queue)
 {
   do_add_timer_queue(queue);
 }
 
 template <typename Time_Traits>
 void epoll_reactor::remove_timer_queue(timer_queue<Time_Traits>& queue)
 {
   do_remove_timer_queue(queue);
 }
 
 template <typename Time_Traits>
 void epoll_reactor::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)
+    typename timer_queue<Time_Traits>::per_timer_data& timer, timer_op* op)
 {
   mutex::scoped_lock lock(mutex_);
 
   if (shutdown_)
   {
     io_service_.post_immediate_completion(op);
     return;
   }
 
   bool earliest = queue.enqueue_timer(time, timer, op);
   io_service_.work_started();
   if (earliest)
     update_timeout();
 }
 
 template <typename Time_Traits>
 std::size_t epoll_reactor::cancel_timer(timer_queue<Time_Traits>& queue,
-    typename timer_queue<Time_Traits>::per_timer_data& timer,
-    std::size_t max_cancelled)
+    typename timer_queue<Time_Traits>::per_timer_data& timer)
 {
   mutex::scoped_lock lock(mutex_);
   op_queue<operation> ops;
-  std::size_t n = queue.cancel_timer(timer, ops, max_cancelled);
+  std::size_t n = queue.cancel_timer(timer, ops);
   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_HAS_EPOLL)
 
 #endif // BOOST_ASIO_DETAIL_IMPL_EPOLL_REACTOR_HPP
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..5afb891 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/epoll_reactor.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/epoll_reactor.ipp
@@ -1,663 +1,392 @@
 //
 // detail/impl/epoll_reactor.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_IMPL_EPOLL_REACTOR_IPP
 #define BOOST_ASIO_DETAIL_IMPL_EPOLL_REACTOR_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_HAS_EPOLL)
 
 #include <cstddef>
 #include <sys/epoll.h>
 #include <boost/asio/detail/epoll_reactor.hpp>
 #include <boost/asio/detail/throw_error.hpp>
 #include <boost/asio/error.hpp>
 
 #if defined(BOOST_ASIO_HAS_TIMERFD)
 # include <sys/timerfd.h>
 #endif // defined(BOOST_ASIO_HAS_TIMERFD)
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 epoll_reactor::epoll_reactor(boost::asio::io_service& io_service)
   : boost::asio::detail::service_base<epoll_reactor>(io_service),
     io_service_(use_service<io_service_impl>(io_service)),
     mutex_(),
-    interrupter_(),
     epoll_fd_(do_epoll_create()),
-    timer_fd_(do_timerfd_create()),
+#if defined(BOOST_ASIO_HAS_TIMERFD)
+    timer_fd_(timerfd_create(CLOCK_MONOTONIC, 0)),
+#else // defined(BOOST_ASIO_HAS_TIMERFD)
+    timer_fd_(-1),
+#endif // defined(BOOST_ASIO_HAS_TIMERFD)
+    interrupter_(),
     shutdown_(false)
 {
   // Add the interrupter's descriptor to epoll.
   epoll_event ev = { 0, { 0 } };
   ev.events = EPOLLIN | EPOLLERR | EPOLLET;
   ev.data.ptr = &interrupter_;
   epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, interrupter_.read_descriptor(), &ev);
   interrupter_.interrupt();
 
   // Add the timer descriptor to epoll.
   if (timer_fd_ != -1)
   {
     ev.events = EPOLLIN | EPOLLERR;
     ev.data.ptr = &timer_fd_;
     epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, timer_fd_, &ev);
   }
 }
 
 epoll_reactor::~epoll_reactor()
 {
-  if (epoll_fd_ != -1)
-    close(epoll_fd_);
+  close(epoll_fd_);
   if (timer_fd_ != -1)
     close(timer_fd_);
 }
 
 void epoll_reactor::shutdown_service()
 {
   mutex::scoped_lock lock(mutex_);
   shutdown_ = true;
   lock.unlock();
 
   op_queue<operation> ops;
 
   while (descriptor_state* state = registered_descriptors_.first())
   {
     for (int i = 0; i < max_ops; ++i)
       ops.push(state->op_queue_[i]);
     state->shutdown_ = true;
     registered_descriptors_.free(state);
   }
 
   timer_queues_.get_all_timers(ops);
-
-  io_service_.abandon_operations(ops);
-}
-
-void epoll_reactor::fork_service(boost::asio::io_service::fork_event fork_ev)
-{
-  if (fork_ev == boost::asio::io_service::fork_child)
-  {
-    if (epoll_fd_ != -1)
-      ::close(epoll_fd_);
-    epoll_fd_ = -1;
-    epoll_fd_ = do_epoll_create();
-
-    if (timer_fd_ != -1)
-      ::close(timer_fd_);
-    timer_fd_ = -1;
-    timer_fd_ = do_timerfd_create();
-
-    interrupter_.recreate();
-
-    // Add the interrupter's descriptor to epoll.
-    epoll_event ev = { 0, { 0 } };
-    ev.events = EPOLLIN | EPOLLERR | EPOLLET;
-    ev.data.ptr = &interrupter_;
-    epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, interrupter_.read_descriptor(), &ev);
-    interrupter_.interrupt();
-
-    // Add the timer descriptor to epoll.
-    if (timer_fd_ != -1)
-    {
-      ev.events = EPOLLIN | EPOLLERR;
-      ev.data.ptr = &timer_fd_;
-      epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, timer_fd_, &ev);
-    }
-
-    update_timeout();
-
-    // Re-register all descriptors with epoll.
-    mutex::scoped_lock descriptors_lock(registered_descriptors_mutex_);
-    for (descriptor_state* state = registered_descriptors_.first();
-        state != 0; state = state->next_)
-    {
-      ev.events = state->registered_events_;
-      ev.data.ptr = state;
-      int result = epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, state->descriptor_, &ev);
-      if (result != 0)
-      {
-        boost::system::error_code ec(errno,
-            boost::asio::error::get_system_category());
-        boost::asio::detail::throw_error(ec, "epoll re-registration");
-      }
-    }
-  }
 }
 
 void epoll_reactor::init_task()
 {
   io_service_.init_task();
 }
 
 int epoll_reactor::register_descriptor(socket_type descriptor,
     epoll_reactor::per_descriptor_data& descriptor_data)
 {
-  descriptor_data = allocate_descriptor_state();
+  mutex::scoped_lock lock(registered_descriptors_mutex_);
 
-  {
-    mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
-
-    descriptor_data->reactor_ = this;
-    descriptor_data->descriptor_ = descriptor;
-    descriptor_data->shutdown_ = false;
-  }
-
-  epoll_event ev = { 0, { 0 } };
-  ev.events = EPOLLIN | EPOLLERR | EPOLLHUP | EPOLLPRI | EPOLLET;
-  descriptor_data->registered_events_ = ev.events;
-  ev.data.ptr = descriptor_data;
-  int result = epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, descriptor, &ev);
-  if (result != 0)
-    return errno;
-
-  return 0;
-}
-
-int epoll_reactor::register_internal_descriptor(
-    int op_type, socket_type descriptor,
-    epoll_reactor::per_descriptor_data& descriptor_data, reactor_op* op)
-{
-  descriptor_data = allocate_descriptor_state();
+  descriptor_data = registered_descriptors_.alloc();
+  descriptor_data->shutdown_ = false;
 
-  {
-    mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
-
-    descriptor_data->reactor_ = this;
-    descriptor_data->descriptor_ = descriptor;
-    descriptor_data->shutdown_ = false;
-    descriptor_data->op_queue_[op_type].push(op);
-  }
+  lock.unlock();
 
   epoll_event ev = { 0, { 0 } };
-  ev.events = EPOLLIN | EPOLLERR | EPOLLHUP | EPOLLPRI | EPOLLET;
-  descriptor_data->registered_events_ = ev.events;
+  ev.events = EPOLLIN | EPOLLERR | EPOLLHUP | EPOLLOUT | EPOLLPRI | EPOLLET;
   ev.data.ptr = descriptor_data;
   int result = epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, descriptor, &ev);
   if (result != 0)
     return errno;
 
   return 0;
 }
 
-void epoll_reactor::move_descriptor(socket_type,
-    epoll_reactor::per_descriptor_data& target_descriptor_data,
-    epoll_reactor::per_descriptor_data& source_descriptor_data)
-{
-  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)
 {
   if (!descriptor_data)
   {
     op->ec_ = boost::asio::error::bad_descriptor;
     post_immediate_completion(op);
     return;
   }
 
   mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
 
   if (descriptor_data->shutdown_)
   {
     post_immediate_completion(op);
     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);
         return;
       }
-
-      if (op_type == write_op)
-      {
-        if ((descriptor_data->registered_events_ & EPOLLOUT) == 0)
-        {
-          epoll_event ev = { 0, { 0 } };
-          ev.events = descriptor_data->registered_events_ | EPOLLOUT;
-          ev.data.ptr = descriptor_data;
-          if (epoll_ctl(epoll_fd_, EPOLL_CTL_MOD, descriptor, &ev) == 0)
-          {
-            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);
-            return;
-          }
-        }
-      }
     }
     else
     {
-      if (op_type == write_op)
-      {
-        descriptor_data->registered_events_ |= EPOLLOUT;
-      }
-
       epoll_event ev = { 0, { 0 } };
-      ev.events = descriptor_data->registered_events_;
+      ev.events = EPOLLIN | EPOLLERR | EPOLLHUP
+        | EPOLLOUT | EPOLLPRI | EPOLLET;
       ev.data.ptr = descriptor_data;
       epoll_ctl(epoll_fd_, EPOLL_CTL_MOD, descriptor, &ev);
     }
   }
 
   descriptor_data->op_queue_[op_type].push(op);
   io_service_.work_started();
 }
 
 void epoll_reactor::cancel_ops(socket_type,
     epoll_reactor::per_descriptor_data& descriptor_data)
 {
   if (!descriptor_data)
     return;
 
   mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
 
   op_queue<operation> ops;
   for (int i = 0; i < max_ops; ++i)
   {
     while (reactor_op* op = descriptor_data->op_queue_[i].front())
     {
       op->ec_ = boost::asio::error::operation_aborted;
       descriptor_data->op_queue_[i].pop();
       ops.push(op);
     }
   }
 
   descriptor_lock.unlock();
 
   io_service_.post_deferred_completions(ops);
 }
 
-void epoll_reactor::deregister_descriptor(socket_type descriptor,
-    epoll_reactor::per_descriptor_data& descriptor_data, bool closing)
+void epoll_reactor::close_descriptor(socket_type,
+    epoll_reactor::per_descriptor_data& descriptor_data)
 {
   if (!descriptor_data)
     return;
 
   mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
+  mutex::scoped_lock descriptors_lock(registered_descriptors_mutex_);
 
   if (!descriptor_data->shutdown_)
   {
-    if (closing)
-    {
-      // The descriptor will be automatically removed from the epoll set when
-      // it is closed.
-    }
-    else
-    {
-      epoll_event ev = { 0, { 0 } };
-      epoll_ctl(epoll_fd_, EPOLL_CTL_DEL, descriptor, &ev);
-    }
+    // Remove the descriptor from the set of known descriptors. The descriptor
+    // will be automatically removed from the epoll set when it is closed.
 
     op_queue<operation> ops;
     for (int i = 0; i < max_ops; ++i)
     {
       while (reactor_op* op = descriptor_data->op_queue_[i].front())
       {
         op->ec_ = boost::asio::error::operation_aborted;
         descriptor_data->op_queue_[i].pop();
         ops.push(op);
       }
     }
 
-    descriptor_data->descriptor_ = -1;
     descriptor_data->shutdown_ = true;
 
     descriptor_lock.unlock();
 
-    free_descriptor_state(descriptor_data);
+    registered_descriptors_.free(descriptor_data);
     descriptor_data = 0;
 
-    io_service_.post_deferred_completions(ops);
-  }
-}
-
-void epoll_reactor::deregister_internal_descriptor(socket_type descriptor,
-    epoll_reactor::per_descriptor_data& descriptor_data)
-{
-  if (!descriptor_data)
-    return;
-
-  mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
-
-  if (!descriptor_data->shutdown_)
-  {
-    epoll_event ev = { 0, { 0 } };
-    epoll_ctl(epoll_fd_, EPOLL_CTL_DEL, descriptor, &ev);
-
-    op_queue<operation> ops;
-    for (int i = 0; i < max_ops; ++i)
-      ops.push(descriptor_data->op_queue_[i]);
+    descriptors_lock.unlock();
 
-    descriptor_data->descriptor_ = -1;
-    descriptor_data->shutdown_ = true;
-
-    descriptor_lock.unlock();
-
-    free_descriptor_state(descriptor_data);
-    descriptor_data = 0;
+    io_service_.post_deferred_completions(ops);
   }
 }
 
 void epoll_reactor::run(bool block, op_queue<operation>& ops)
 {
-  // This code relies on the fact that the task_io_service queues the reactor
-  // task behind all descriptor operations generated by this function. This
-  // means, that by the time we reach this point, any previously returned
-  // descriptor operations have already been dequeued. Therefore it is now safe
-  // for us to reuse and return them for the task_io_service to queue again.
-
   // Calculate a timeout only if timerfd is not used.
   int timeout;
   if (timer_fd_ != -1)
     timeout = block ? -1 : 0;
   else
   {
     mutex::scoped_lock lock(mutex_);
     timeout = block ? get_timeout() : 0;
   }
 
   // Block on the epoll descriptor.
   epoll_event events[128];
   int num_events = epoll_wait(epoll_fd_, events, 128, timeout);
 
 #if defined(BOOST_ASIO_HAS_TIMERFD)
   bool check_timers = (timer_fd_ == -1);
 #else // defined(BOOST_ASIO_HAS_TIMERFD)
   bool check_timers = true;
 #endif // defined(BOOST_ASIO_HAS_TIMERFD)
 
   // Dispatch the waiting events.
   for (int i = 0; i < num_events; ++i)
   {
     void* ptr = events[i].data.ptr;
     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
       // to make it so that we only get woken up when the descriptor's epoll
       // registration is updated.
 
 #if defined(BOOST_ASIO_HAS_TIMERFD)
       if (timer_fd_ == -1)
         check_timers = true;
 #else // defined(BOOST_ASIO_HAS_TIMERFD)
       check_timers = true;
 #endif // defined(BOOST_ASIO_HAS_TIMERFD)
     }
 #if defined(BOOST_ASIO_HAS_TIMERFD)
     else if (ptr == &timer_fd_)
     {
       check_timers = true;
     }
 #endif // defined(BOOST_ASIO_HAS_TIMERFD)
     else
     {
-      // The descriptor operation doesn't count as work in and of itself, so we
-      // don't call work_started() here. This still allows the io_service to
-      // stop if the only remaining operations are descriptor operations.
       descriptor_state* descriptor_data = static_cast<descriptor_state*>(ptr);
-      descriptor_data->set_ready_events(events[i].events);
-      ops.push(descriptor_data);
+      mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
+
+      // 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)
+      {
+        if (events[i].events & (flag[j] | EPOLLERR | EPOLLHUP))
+        {
+          while (reactor_op* op = descriptor_data->op_queue_[j].front())
+          {
+            if (op->perform())
+            {
+              descriptor_data->op_queue_[j].pop();
+              ops.push(op);
+            }
+            else
+              break;
+          }
+        }
+      }
     }
   }
 
   if (check_timers)
   {
     mutex::scoped_lock common_lock(mutex_);
     timer_queues_.get_ready_timers(ops);
 
 #if defined(BOOST_ASIO_HAS_TIMERFD)
     if (timer_fd_ != -1)
     {
       itimerspec new_timeout;
       itimerspec old_timeout;
       int flags = get_timeout(new_timeout);
       timerfd_settime(timer_fd_, flags, &new_timeout, &old_timeout);
     }
 #endif // defined(BOOST_ASIO_HAS_TIMERFD)
   }
 }
 
 void epoll_reactor::interrupt()
 {
   epoll_event ev = { 0, { 0 } };
   ev.events = EPOLLIN | EPOLLERR | EPOLLET;
   ev.data.ptr = &interrupter_;
   epoll_ctl(epoll_fd_, EPOLL_CTL_MOD, interrupter_.read_descriptor(), &ev);
 }
 
 int epoll_reactor::do_epoll_create()
 {
-#if defined(EPOLL_CLOEXEC)
-  int fd = epoll_create1(EPOLL_CLOEXEC);
-#else // defined(EPOLL_CLOEXEC)
-  int fd = -1;
-  errno = EINVAL;
-#endif // defined(EPOLL_CLOEXEC)
-
-  if (fd == -1 && (errno == EINVAL || errno == ENOSYS))
-  {
-    fd = epoll_create(epoll_size);
-    if (fd != -1)
-      ::fcntl(fd, F_SETFD, FD_CLOEXEC);
-  }
-
+  int fd = epoll_create(epoll_size);
   if (fd == -1)
   {
     boost::system::error_code ec(errno,
         boost::asio::error::get_system_category());
     boost::asio::detail::throw_error(ec, "epoll");
   }
-
   return fd;
 }
 
-int epoll_reactor::do_timerfd_create()
-{
-#if defined(BOOST_ASIO_HAS_TIMERFD)
-# if defined(TFD_CLOEXEC)
-  int fd = timerfd_create(CLOCK_MONOTONIC, TFD_CLOEXEC);
-# else // defined(TFD_CLOEXEC)
-  int fd = -1;
-  errno = EINVAL;
-# endif // defined(TFD_CLOEXEC)
-
-  if (fd == -1 && errno == EINVAL)
-  {
-    fd = timerfd_create(CLOCK_MONOTONIC, 0);
-    if (fd != -1)
-      ::fcntl(fd, F_SETFD, FD_CLOEXEC);
-  }
-
-  return fd;
-#else // defined(BOOST_ASIO_HAS_TIMERFD)
-  return -1;
-#endif // defined(BOOST_ASIO_HAS_TIMERFD)
-}
-
-epoll_reactor::descriptor_state* epoll_reactor::allocate_descriptor_state()
-{
-  mutex::scoped_lock descriptors_lock(registered_descriptors_mutex_);
-  return registered_descriptors_.alloc();
-}
-
-void epoll_reactor::free_descriptor_state(epoll_reactor::descriptor_state* s)
-{
-  mutex::scoped_lock descriptors_lock(registered_descriptors_mutex_);
-  registered_descriptors_.free(s);
-}
-
 void epoll_reactor::do_add_timer_queue(timer_queue_base& queue)
 {
   mutex::scoped_lock lock(mutex_);
   timer_queues_.insert(&queue);
 }
 
 void epoll_reactor::do_remove_timer_queue(timer_queue_base& queue)
 {
   mutex::scoped_lock lock(mutex_);
   timer_queues_.erase(&queue);
 }
 
 void epoll_reactor::update_timeout()
 {
 #if defined(BOOST_ASIO_HAS_TIMERFD)
   if (timer_fd_ != -1)
   {
     itimerspec new_timeout;
     itimerspec old_timeout;
     int flags = get_timeout(new_timeout);
     timerfd_settime(timer_fd_, flags, &new_timeout, &old_timeout);
     return;
   }
 #endif // defined(BOOST_ASIO_HAS_TIMERFD)
   interrupt();
 }
 
 int epoll_reactor::get_timeout()
 {
   // By default we will wait no longer than 5 minutes. This will ensure that
   // any changes to the system clock are detected after no longer than this.
   return timer_queues_.wait_duration_msec(5 * 60 * 1000);
 }
 
 #if defined(BOOST_ASIO_HAS_TIMERFD)
 int epoll_reactor::get_timeout(itimerspec& ts)
 {
   ts.it_interval.tv_sec = 0;
   ts.it_interval.tv_nsec = 0;
 
   long usec = timer_queues_.wait_duration_usec(5 * 60 * 1000 * 1000);
   ts.it_value.tv_sec = usec / 1000000;
   ts.it_value.tv_nsec = usec ? (usec % 1000000) * 1000 : 1;
 
   return usec ? 0 : TFD_TIMER_ABSTIME;
 }
 #endif // defined(BOOST_ASIO_HAS_TIMERFD)
 
-struct epoll_reactor::perform_io_cleanup_on_block_exit
-{
-  explicit perform_io_cleanup_on_block_exit(epoll_reactor* r)
-    : reactor_(r), first_op_(0)
-  {
-  }
-
-  ~perform_io_cleanup_on_block_exit()
-  {
-    if (first_op_)
-    {
-      // Post the remaining completed operations for invocation.
-      if (!ops_.empty())
-        reactor_->io_service_.post_deferred_completions(ops_);
-
-      // A user-initiated operation has completed, but there's no need to
-      // explicitly call work_finished() here. Instead, we'll take advantage of
-      // the fact that the task_io_service will call work_finished() once we
-      // return.
-    }
-    else
-    {
-      // No user-initiated operations have completed, so we need to compensate
-      // for the work_finished() call that the task_io_service will make once
-      // this operation returns.
-      reactor_->io_service_.work_started();
-    }
-  }
-
-  epoll_reactor* reactor_;
-  op_queue<operation> ops_;
-  operation* first_op_;
-};
-
-epoll_reactor::descriptor_state::descriptor_state()
-  : operation(&epoll_reactor::descriptor_state::do_complete)
-{
-}
-
-operation* epoll_reactor::descriptor_state::perform_io(uint32_t events)
-{
-  perform_io_cleanup_on_block_exit io_cleanup(reactor_);
-  mutex::scoped_lock descriptor_lock(mutex_);
-
-  // 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)
-  {
-    if (events & (flag[j] | EPOLLERR | EPOLLHUP))
-    {
-      while (reactor_op* op = op_queue_[j].front())
-      {
-        if (op->perform())
-        {
-          op_queue_[j].pop();
-          io_cleanup.ops_.push(op);
-        }
-        else
-          break;
-      }
-    }
-  }
-
-  // The first operation will be returned for completion now. The others will
-  // be posted for later by the io_cleanup object's destructor.
-  io_cleanup.first_op_ = io_cleanup.ops_.front();
-  io_cleanup.ops_.pop();
-  return io_cleanup.first_op_;
-}
-
-void epoll_reactor::descriptor_state::do_complete(
-    io_service_impl* owner, operation* base,
-    const boost::system::error_code& ec, std::size_t bytes_transferred)
-{
-  if (owner)
-  {
-    descriptor_state* descriptor_data = static_cast<descriptor_state*>(base);
-    uint32_t events = static_cast<uint32_t>(bytes_transferred);
-    if (operation* op = descriptor_data->perform_io(events))
-    {
-      op->complete(*owner, ec, 0);
-    }
-  }
-}
-
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // defined(BOOST_ASIO_HAS_EPOLL)
 
 #endif // BOOST_ASIO_DETAIL_IMPL_EPOLL_REACTOR_IPP
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..d270b31 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,152 +1,113 @@
 //
 // detail/impl/eventfd_select_interrupter.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2011 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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_IMPL_EVENTFD_SELECT_INTERRUPTER_IPP
 #define BOOST_ASIO_DETAIL_IMPL_EVENTFD_SELECT_INTERRUPTER_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_HAS_EVENTFD)
 
 #include <sys/stat.h>
 #include <sys/types.h>
 #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/eventfd_select_interrupter.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 {
 
 eventfd_select_interrupter::eventfd_select_interrupter()
 {
-  open_descriptors();
-}
-
-void eventfd_select_interrupter::open_descriptors()
-{
 #if __GLIBC__ == 2 && __GLIBC_MINOR__ < 8
   write_descriptor_ = read_descriptor_ = syscall(__NR_eventfd, 0);
+#else // __GLIBC__ == 2 && __GLIBC_MINOR__ < 8
+  write_descriptor_ = read_descriptor_ = ::eventfd(0, 0);
+#endif // __GLIBC__ == 2 && __GLIBC_MINOR__ < 8
   if (read_descriptor_ != -1)
   {
     ::fcntl(read_descriptor_, F_SETFL, O_NONBLOCK);
-    ::fcntl(read_descriptor_, F_SETFD, FD_CLOEXEC);
-  }
-#else // __GLIBC__ == 2 && __GLIBC_MINOR__ < 8
-# if defined(EFD_CLOEXEC) && defined(EFD_NONBLOCK)
-  write_descriptor_ = read_descriptor_ =
-    ::eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK);
-# else // defined(EFD_CLOEXEC) && defined(EFD_NONBLOCK)
-  errno = EINVAL;
-  write_descriptor_ = read_descriptor_ = -1;
-# endif // defined(EFD_CLOEXEC) && defined(EFD_NONBLOCK)
-  if (read_descriptor_ == -1 && errno == EINVAL)
-  {
-    write_descriptor_ = read_descriptor_ = ::eventfd(0, 0);
-    if (read_descriptor_ != -1)
-    {
-      ::fcntl(read_descriptor_, F_SETFL, O_NONBLOCK);
-      ::fcntl(read_descriptor_, F_SETFD, FD_CLOEXEC);
-    }
   }
-#endif // __GLIBC__ == 2 && __GLIBC_MINOR__ < 8
-
-  if (read_descriptor_ == -1)
+  else
   {
     int pipe_fds[2];
     if (pipe(pipe_fds) == 0)
     {
       read_descriptor_ = pipe_fds[0];
       ::fcntl(read_descriptor_, F_SETFL, O_NONBLOCK);
-      ::fcntl(read_descriptor_, F_SETFD, FD_CLOEXEC);
       write_descriptor_ = pipe_fds[1];
       ::fcntl(write_descriptor_, F_SETFL, O_NONBLOCK);
-      ::fcntl(write_descriptor_, F_SETFD, FD_CLOEXEC);
     }
     else
     {
       boost::system::error_code ec(errno,
           boost::asio::error::get_system_category());
       boost::asio::detail::throw_error(ec, "eventfd_select_interrupter");
     }
   }
 }
 
 eventfd_select_interrupter::~eventfd_select_interrupter()
 {
-  close_descriptors();
-}
-
-void eventfd_select_interrupter::close_descriptors()
-{
   if (write_descriptor_ != -1 && write_descriptor_ != read_descriptor_)
     ::close(write_descriptor_);
   if (read_descriptor_ != -1)
     ::close(read_descriptor_);
 }
 
-void eventfd_select_interrupter::recreate()
-{
-  close_descriptors();
-
-  write_descriptor_ = -1;
-  read_descriptor_ = -1;
-
-  open_descriptors();
-}
-
 void eventfd_select_interrupter::interrupt()
 {
   uint64_t counter(1UL);
   int result = ::write(write_descriptor_, &counter, sizeof(uint64_t));
   (void)result;
 }
 
 bool eventfd_select_interrupter::reset()
 {
   if (write_descriptor_ == read_descriptor_)
   {
     for (;;)
     {
       // Only perform one read. The kernel maintains an atomic counter.
       uint64_t counter(0);
       errno = 0;
       int bytes_read = ::read(read_descriptor_, &counter, sizeof(uint64_t));
       if (bytes_read < 0 && errno == EINTR)
         continue;
       bool was_interrupted = (bytes_read > 0);
       return was_interrupted;
     }
   }
   else
   {
     for (;;)
     {
       // Clear all data from the pipe.
       char data[1024];
       int 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));
diff --git a/3rdParty/Boost/src/boost/asio/detail/impl/handler_tracking.ipp b/3rdParty/Boost/src/boost/asio/detail/impl/handler_tracking.ipp
deleted file mode 100644
index 70342e3..0000000
--- a/3rdParty/Boost/src/boost/asio/detail/impl/handler_tracking.ipp
+++ /dev/null
@@ -1,299 +0,0 @@
-//
-// detail/impl/handler_tracking.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// 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_IMPL_HANDLER_TRACKING_IPP
-#define BOOST_ASIO_DETAIL_IMPL_HANDLER_TRACKING_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_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)
-# include <unistd.h>
-#endif // !defined(BOOST_WINDOWS)
-
-#include <boost/asio/detail/push_options.hpp>
-
-namespace boost {
-namespace asio {
-namespace detail {
-
-struct handler_tracking::tracking_state
-{
-  static_mutex mutex_;
-  boost::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 };
-  return &state;
-}
-
-void handler_tracking::init()
-{
-  static tracking_state* state = get_state();
-
-  state->mutex_.init();
-
-  static_mutex::scoped_lock lock(state->mutex_);
-  if (state->current_completion_ == 0)
-    state->current_completion_ = new tss_ptr<completion>;
-}
-
-void handler_tracking::creation(handler_tracking::tracked_handler* h,
-    const char* object_type, void* object, const char* op_name)
-{
-  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;
-
-  boost::uint64_t current_id = 0;
-  if (completion* current_completion = *state->current_completion_)
-    current_id = current_completion->id_;
-
-  write_line(
-#if defined(BOOST_WINDOWS)
-      "@asio|%I64u.%06I64u|%I64u*%I64u|%.20s@%p.%.50s\n",
-#else // defined(BOOST_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),
-      current_id, h->id_, object_type, object, op_name);
-}
-
-handler_tracking::completion::completion(handler_tracking::tracked_handler* h)
-  : id_(h->id_),
-    invoked_(false),
-    next_(*get_state()->current_completion_)
-{
-  *get_state()->current_completion_ = this;
-}
-
-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;
-
-    write_line(
-#if defined(BOOST_WINDOWS)
-        "@asio|%I64u.%06I64u|%c%I64u|\n",
-#else // defined(BOOST_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),
-        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;
-
-  write_line(
-#if defined(BOOST_WINDOWS)
-      "@asio|%I64u.%06I64u|>%I64u|\n",
-#else // defined(BOOST_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_);
-
-  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;
-
-  write_line(
-#if defined(BOOST_WINDOWS)
-      "@asio|%I64u.%06I64u|>%I64u|ec=%.20s:%d\n",
-#else // defined(BOOST_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),
-      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;
-
-  write_line(
-#if defined(BOOST_WINDOWS)
-      "@asio|%I64u.%06I64u|>%I64u|ec=%.20s:%d,bytes_transferred=%I64u\n",
-#else // defined(BOOST_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),
-      id_, ec.category().name(), ec.value(),
-      static_cast<boost::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;
-
-  write_line(
-#if defined(BOOST_WINDOWS)
-      "@asio|%I64u.%06I64u|>%I64u|ec=%.20s:%d,signal_number=%d\n",
-#else // defined(BOOST_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),
-      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;
-
-  write_line(
-#if defined(BOOST_WINDOWS)
-      "@asio|%I64u.%06I64u|>%I64u|ec=%.20s:%d,%.50s\n",
-#else // defined(BOOST_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),
-      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;
-
-    write_line(
-#if defined(BOOST_WINDOWS)
-        "@asio|%I64u.%06I64u|<%I64u|\n",
-#else // defined(BOOST_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_);
-
-    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;
-
-  unsigned long long current_id = 0;
-  if (completion* current_completion = *state->current_completion_)
-    current_id = current_completion->id_;
-
-  write_line(
-#if defined(BOOST_WINDOWS)
-      "@asio|%I64u.%06I64u|%I64u|%.20s@%p.%.50s\n",
-#else // defined(BOOST_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),
-      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)
-  int length = vsprintf_s(line, sizeof(line), format, args);
-#else // BOOST_WORKAROUND(BOOST_MSVC, >= 1400) && !defined(UNDER_CE)
-  int length = vsprintf(line, format, args);
-#endif // BOOST_WORKAROUND(BOOST_MSVC, >= 1400) && !defined(UNDER_CE)
-
-  va_end(args);
-
-#if defined(BOOST_WINDOWS)
-  HANDLE stderr_handle = ::GetStdHandle(STD_ERROR_HANDLE);
-  DWORD bytes_written = 0;
-  ::WriteFile(stderr_handle, line, length, &bytes_written, 0);
-#else // defined(BOOST_WINDOWS)
-  ::write(STDERR_FILENO, line, length);
-#endif // defined(BOOST_WINDOWS)
-}
-
-} // namespace detail
-} // namespace asio
-} // namespace boost
-
-#include <boost/asio/detail/pop_options.hpp>
-
-#endif // defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING)
-
-#endif // BOOST_ASIO_DETAIL_IMPL_HANDLER_TRACKING_IPP
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..779f272 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/kqueue_reactor.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/kqueue_reactor.hpp
@@ -1,82 +1,81 @@
 //
 // detail/impl/kqueue_reactor.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2011 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_IMPL_KQUEUE_REACTOR_HPP
 #define BOOST_ASIO_DETAIL_IMPL_KQUEUE_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_HAS_KQUEUE)
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 template <typename Time_Traits>
 void kqueue_reactor::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 kqueue_reactor::remove_timer_queue(timer_queue<Time_Traits>& queue)
 {
   do_remove_timer_queue(queue);
 }
 
 template <typename Time_Traits>
 void kqueue_reactor::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)
+    typename timer_queue<Time_Traits>::per_timer_data& timer, timer_op* op)
 {
   boost::asio::detail::mutex::scoped_lock lock(mutex_);
 
   if (shutdown_)
   {
     io_service_.post_immediate_completion(op);
     return;
   }
 
   bool earliest = queue.enqueue_timer(time, timer, op);
   io_service_.work_started();
   if (earliest)
     interrupt();
 }
 
 template <typename Time_Traits>
 std::size_t kqueue_reactor::cancel_timer(timer_queue<Time_Traits>& queue,
-    typename timer_queue<Time_Traits>::per_timer_data& timer,
-    std::size_t max_cancelled)
+    typename timer_queue<Time_Traits>::per_timer_data& timer)
 {
   boost::asio::detail::mutex::scoped_lock lock(mutex_);
   op_queue<operation> ops;
-  std::size_t n = queue.cancel_timer(timer, ops, max_cancelled);
+  std::size_t n = queue.cancel_timer(timer, ops);
   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_HAS_KQUEUE)
 
 #endif // BOOST_ASIO_DETAIL_IMPL_KQUEUE_REACTOR_HPP
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..3ac9eae 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/kqueue_reactor.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/kqueue_reactor.ipp
@@ -1,214 +1,130 @@
 //
 // detail/impl/kqueue_reactor.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2011 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_IMPL_KQUEUE_REACTOR_IPP
 #define BOOST_ASIO_DETAIL_IMPL_KQUEUE_REACTOR_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_HAS_KQUEUE)
 
 #include <boost/asio/detail/kqueue_reactor.hpp>
 #include <boost/asio/detail/throw_error.hpp>
 #include <boost/asio/error.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 #if defined(__NetBSD__)
 # define BOOST_ASIO_KQUEUE_EV_SET(ev, ident, filt, flags, fflags, data, udata) \
-    EV_SET(ev, ident, filt, flags, fflags, data, \
-      reinterpret_cast<intptr_t>(static_cast<void*>(udata)))
+    EV_SET(ev, ident, filt, flags, fflags, \
+      data, reinterpret_cast<intptr_t>(udata))
 #else
 # define BOOST_ASIO_KQUEUE_EV_SET(ev, ident, filt, flags, fflags, data, udata) \
     EV_SET(ev, ident, filt, flags, fflags, data, udata)
 #endif
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 kqueue_reactor::kqueue_reactor(boost::asio::io_service& io_service)
   : boost::asio::detail::service_base<kqueue_reactor>(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();
 }
 
 kqueue_reactor::~kqueue_reactor()
 {
   close(kqueue_fd_);
 }
 
 void kqueue_reactor::shutdown_service()
 {
   mutex::scoped_lock lock(mutex_);
   shutdown_ = true;
   lock.unlock();
 
   op_queue<operation> ops;
 
   while (descriptor_state* state = registered_descriptors_.first())
   {
     for (int i = 0; i < max_ops; ++i)
       ops.push(state->op_queue_[i]);
     state->shutdown_ = true;
     registered_descriptors_.free(state);
   }
 
   timer_queues_.get_all_timers(ops);
-
-  io_service_.abandon_operations(ops);
-}
-
-void kqueue_reactor::fork_service(boost::asio::io_service::fork_event fork_ev)
-{
-  if (fork_ev == boost::asio::io_service::fork_child)
-  {
-    // The kqueue descriptor is automatically closed in the child.
-    kqueue_fd_ = -1;
-    kqueue_fd_ = do_kqueue_create();
-
-    interrupter_.recreate();
-
-    // 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::system::error_code error(errno,
-            boost::asio::error::get_system_category());
-        boost::asio::detail::throw_error(error);
-      }
-    }
-  }
 }
 
 void kqueue_reactor::init_task()
 {
   io_service_.init_task();
 }
 
-int kqueue_reactor::register_descriptor(socket_type descriptor,
+int kqueue_reactor::register_descriptor(socket_type,
     kqueue_reactor::per_descriptor_data& descriptor_data)
 {
-  descriptor_data = allocate_descriptor_state();
-
-  mutex::scoped_lock lock(descriptor_data->mutex_);
-
-  descriptor_data->descriptor_ = descriptor;
-  descriptor_data->shutdown_ = false;
-
-  return 0;
-}
-
-int kqueue_reactor::register_internal_descriptor(
-    int op_type, socket_type descriptor,
-    kqueue_reactor::per_descriptor_data& descriptor_data, reactor_op* op)
-{
-  descriptor_data = allocate_descriptor_state();
+  mutex::scoped_lock lock(registered_descriptors_mutex_);
 
-  mutex::scoped_lock lock(descriptor_data->mutex_);
-
-  descriptor_data->descriptor_ = descriptor;
+  descriptor_data = registered_descriptors_.alloc();
   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);
 
   return 0;
 }
 
-void kqueue_reactor::move_descriptor(socket_type,
-    kqueue_reactor::per_descriptor_data& target_descriptor_data,
-    kqueue_reactor::per_descriptor_data& source_descriptor_data)
-{
-  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)
 {
   if (!descriptor_data)
   {
     op->ec_ = boost::asio::error::bad_descriptor;
     post_immediate_completion(op);
     return;
   }
 
   mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
 
   if (descriptor_data->shutdown_)
   {
     post_immediate_completion(op);
     return;
   }
 
   bool first = descriptor_data->op_queue_[op_type].empty();
   if (first)
   {
     if (allow_speculative)
     {
       if (op_type != read_op || descriptor_data->op_queue_[except_op].empty())
       {
         if (op->perform())
         {
           descriptor_lock.unlock();
           io_service_.post_immediate_completion(op);
           return;
         }
       }
     }
   }
@@ -239,146 +155,105 @@ void kqueue_reactor::start_op(int op_type, socket_type descriptor,
 
     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);
     }
   }
 }
 
 void kqueue_reactor::cancel_ops(socket_type,
     kqueue_reactor::per_descriptor_data& descriptor_data)
 {
   if (!descriptor_data)
     return;
 
   mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
 
   op_queue<operation> ops;
   for (int i = 0; i < max_ops; ++i)
   {
     while (reactor_op* op = descriptor_data->op_queue_[i].front())
     {
       op->ec_ = boost::asio::error::operation_aborted;
       descriptor_data->op_queue_[i].pop();
       ops.push(op);
     }
   }
 
   descriptor_lock.unlock();
 
   io_service_.post_deferred_completions(ops);
 }
 
-void kqueue_reactor::deregister_descriptor(socket_type descriptor,
-    kqueue_reactor::per_descriptor_data& descriptor_data, bool closing)
+void kqueue_reactor::close_descriptor(socket_type,
+    kqueue_reactor::per_descriptor_data& descriptor_data)
 {
   if (!descriptor_data)
     return;
 
   mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
+  mutex::scoped_lock descriptors_lock(registered_descriptors_mutex_);
 
   if (!descriptor_data->shutdown_)
   {
-    if (closing)
-    {
-      // The descriptor will be automatically removed from the kqueue when it
-      // is closed.
-    }
-    else
-    {
-      struct kevent events[2];
-      BOOST_ASIO_KQUEUE_EV_SET(&events[0], descriptor,
-          EVFILT_READ, EV_DELETE, 0, 0, 0);
-      BOOST_ASIO_KQUEUE_EV_SET(&events[1], descriptor,
-          EVFILT_WRITE, EV_DELETE, 0, 0, 0);
-      ::kevent(kqueue_fd_, events, 2, 0, 0, 0);
-    }
+    // Remove the descriptor from the set of known descriptors. The descriptor
+    // will be automatically removed from the kqueue set when it is closed.
 
     op_queue<operation> ops;
     for (int i = 0; i < max_ops; ++i)
     {
       while (reactor_op* op = descriptor_data->op_queue_[i].front())
       {
         op->ec_ = boost::asio::error::operation_aborted;
         descriptor_data->op_queue_[i].pop();
         ops.push(op);
       }
     }
 
-    descriptor_data->descriptor_ = -1;
     descriptor_data->shutdown_ = true;
 
     descriptor_lock.unlock();
 
-    free_descriptor_state(descriptor_data);
+    registered_descriptors_.free(descriptor_data);
     descriptor_data = 0;
 
-    io_service_.post_deferred_completions(ops);
-  }
-}
-
-void kqueue_reactor::deregister_internal_descriptor(socket_type descriptor,
-    kqueue_reactor::per_descriptor_data& descriptor_data)
-{
-  if (!descriptor_data)
-    return;
-
-  mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
-
-  if (!descriptor_data->shutdown_)
-  {
-    struct kevent events[2];
-    BOOST_ASIO_KQUEUE_EV_SET(&events[0], descriptor,
-        EVFILT_READ, EV_DELETE, 0, 0, 0);
-    BOOST_ASIO_KQUEUE_EV_SET(&events[1], descriptor,
-        EVFILT_WRITE, EV_DELETE, 0, 0, 0);
-    ::kevent(kqueue_fd_, events, 2, 0, 0, 0);
-
-    op_queue<operation> ops;
-    for (int i = 0; i < max_ops; ++i)
-      ops.push(descriptor_data->op_queue_[i]);
+    descriptors_lock.unlock();
 
-    descriptor_data->descriptor_ = -1;
-    descriptor_data->shutdown_ = true;
-
-    descriptor_lock.unlock();
-
-    free_descriptor_state(descriptor_data);
-    descriptor_data = 0;
+    io_service_.post_deferred_completions(ops);
   }
 }
 
 void kqueue_reactor::run(bool block, op_queue<operation>& ops)
 {
   mutex::scoped_lock lock(mutex_);
 
   // Determine how long to block while waiting for events.
   timespec timeout_buf = { 0, 0 };
   timespec* timeout = block ? get_timeout(timeout_buf) : &timeout_buf;
 
   lock.unlock();
 
   // Block on the kqueue descriptor.
   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.
     }
     else
     {
       descriptor_state* descriptor_data = static_cast<descriptor_state*>(ptr);
       mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
 
       // Exception operations must be processed first to ensure that any
       // out-of-band data is read before normal data.
 #if defined(__NetBSD__)
@@ -447,80 +322,68 @@ void kqueue_reactor::run(bool block, op_queue<operation>& ops)
           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);
 }
 
 int kqueue_reactor::do_kqueue_create()
 {
   int fd = ::kqueue();
   if (fd == -1)
   {
     boost::system::error_code ec(errno,
         boost::asio::error::get_system_category());
     boost::asio::detail::throw_error(ec, "kqueue");
   }
   return fd;
 }
 
-kqueue_reactor::descriptor_state* kqueue_reactor::allocate_descriptor_state()
-{
-  mutex::scoped_lock descriptors_lock(registered_descriptors_mutex_);
-  return registered_descriptors_.alloc();
-}
-
-void kqueue_reactor::free_descriptor_state(kqueue_reactor::descriptor_state* s)
-{
-  mutex::scoped_lock descriptors_lock(registered_descriptors_mutex_);
-  registered_descriptors_.free(s);
-}
-
 void kqueue_reactor::do_add_timer_queue(timer_queue_base& queue)
 {
   mutex::scoped_lock lock(mutex_);
   timer_queues_.insert(&queue);
 }
 
 void kqueue_reactor::do_remove_timer_queue(timer_queue_base& queue)
 {
   mutex::scoped_lock lock(mutex_);
   timer_queues_.erase(&queue);
 }
 
 timespec* kqueue_reactor::get_timeout(timespec& ts)
 {
   // By default we will wait no longer than 5 minutes. This will ensure that
   // any changes to the system clock are detected after no longer than this.
   long usec = timer_queues_.wait_duration_usec(5 * 60 * 1000 * 1000);
   ts.tv_sec = usec / 1000000;
   ts.tv_nsec = (usec % 1000000) * 1000;
   return &ts;
 }
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #undef BOOST_ASIO_KQUEUE_EV_SET
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // defined(BOOST_ASIO_HAS_KQUEUE)
 
 #endif // BOOST_ASIO_DETAIL_IMPL_KQUEUE_REACTOR_IPP
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..9a0a872 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,123 +1,98 @@
 //
 // detail/impl/pipe_select_interrupter.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_IMPL_PIPE_SELECT_INTERRUPTER_IPP
 #define BOOST_ASIO_DETAIL_IMPL_PIPE_SELECT_INTERRUPTER_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_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/throw_error.hpp>
 #include <boost/asio/error.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 pipe_select_interrupter::pipe_select_interrupter()
 {
-  open_descriptors();
-}
-
-void pipe_select_interrupter::open_descriptors()
-{
   int pipe_fds[2];
   if (pipe(pipe_fds) == 0)
   {
     read_descriptor_ = pipe_fds[0];
     ::fcntl(read_descriptor_, F_SETFL, O_NONBLOCK);
     write_descriptor_ = pipe_fds[1];
     ::fcntl(write_descriptor_, F_SETFL, O_NONBLOCK);
-
-#if defined(FD_CLOEXEC)
-    ::fcntl(read_descriptor_, F_SETFD, FD_CLOEXEC);
-    ::fcntl(write_descriptor_, F_SETFD, FD_CLOEXEC);
-#endif // defined(FD_CLOEXEC)
   }
   else
   {
     boost::system::error_code ec(errno,
         boost::asio::error::get_system_category());
     boost::asio::detail::throw_error(ec, "pipe_select_interrupter");
   }
 }
 
 pipe_select_interrupter::~pipe_select_interrupter()
 {
-  close_descriptors();
-}
-
-void pipe_select_interrupter::close_descriptors()
-{
   if (read_descriptor_ != -1)
     ::close(read_descriptor_);
   if (write_descriptor_ != -1)
     ::close(write_descriptor_);
 }
 
-void pipe_select_interrupter::recreate()
-{
-  close_descriptors();
-
-  write_descriptor_ = -1;
-  read_descriptor_ = -1;
-
-  open_descriptors();
-}
-
 void pipe_select_interrupter::interrupt()
 {
   char byte = 0;
   int 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));
     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;
   }
 }
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // !defined(BOOST_ASIO_HAS_EVENTFD)
 #endif // !defined(__SYMBIAN32__)
 #endif // !defined(__CYGWIN__)
 #endif // !defined(BOOST_WINDOWS)
 
 #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..893e8cc 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/posix_event.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/posix_event.ipp
@@ -1,40 +1,40 @@
 //
 // detail/impl/posix_event.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_IMPL_POSIX_EVENT_IPP
 #define BOOST_ASIO_DETAIL_IMPL_POSIX_EVENT_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_HAS_PTHREADS) && !defined(BOOST_ASIO_DISABLE_THREADS)
 
 #include <boost/asio/detail/posix_event.hpp>
 #include <boost/asio/detail/throw_error.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 posix_event::posix_event()
   : signalled_(false)
 {
   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");
 }
 
 } // namespace detail
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..908bfab 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/posix_mutex.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/posix_mutex.ipp
@@ -1,40 +1,40 @@
 //
 // detail/impl/posix_mutex.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_IMPL_POSIX_MUTEX_IPP
 #define BOOST_ASIO_DETAIL_IMPL_POSIX_MUTEX_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_HAS_PTHREADS) && !defined(BOOST_ASIO_DISABLE_THREADS)
 
 #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>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 posix_mutex::posix_mutex()
 {
   int error = ::pthread_mutex_init(&mutex_, 0);
   boost::system::error_code ec(error,
       boost::asio::error::get_system_category());
   boost::asio::detail::throw_error(ec, "mutex");
 }
 
 } // namespace detail
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..feb6dd1 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/posix_thread.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/posix_thread.ipp
@@ -1,40 +1,40 @@
 //
 // detail/impl/posix_thread.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_IMPL_POSIX_THREAD_IPP
 #define BOOST_ASIO_DETAIL_IMPL_POSIX_THREAD_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_HAS_PTHREADS) && !defined(BOOST_ASIO_DISABLE_THREADS)
 
 #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>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 posix_thread::~posix_thread()
 {
   if (!joined_)
     ::pthread_detach(thread_);
 }
 
 void posix_thread::join()
 {
   if (!joined_)
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..89c1bf5 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,40 +1,40 @@
 //
 // detail/impl/posix_tss_ptr.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_IMPL_POSIX_TSS_PTR_IPP
 #define BOOST_ASIO_DETAIL_IMPL_POSIX_TSS_PTR_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_HAS_PTHREADS) && !defined(BOOST_ASIO_DISABLE_THREADS)
 
 #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>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 void posix_tss_ptr_create(pthread_key_t& key)
 {
   int error = ::pthread_key_create(&key, 0);
   boost::system::error_code ec(error,
       boost::asio::error::get_system_category());
   boost::asio::detail::throw_error(ec, "tss");
 }
 
 } // namespace detail
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..a1ee09a 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,205 +1,138 @@
 //
 // detail/impl/reactive_descriptor_service.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_IMPL_REACTIVE_DESCRIPTOR_SERVICE_IPP
 #define BOOST_ASIO_DETAIL_IMPL_REACTIVE_DESCRIPTOR_SERVICE_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_WINDOWS) && !defined(__CYGWIN__)
 
 #include <boost/asio/error.hpp>
 #include <boost/asio/detail/reactive_descriptor_service.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 reactive_descriptor_service::reactive_descriptor_service(
     boost::asio::io_service& io_service)
   : reactor_(boost::asio::use_service<reactor>(io_service))
 {
   reactor_.init_task();
 }
 
 void reactive_descriptor_service::shutdown_service()
 {
 }
 
 void reactive_descriptor_service::construct(
     reactive_descriptor_service::implementation_type& impl)
 {
   impl.descriptor_ = -1;
   impl.state_ = 0;
 }
 
-void reactive_descriptor_service::move_construct(
-    reactive_descriptor_service::implementation_type& impl,
-    reactive_descriptor_service::implementation_type& other_impl)
-{
-  impl.descriptor_ = other_impl.descriptor_;
-  other_impl.descriptor_ = -1;
-
-  impl.state_ = other_impl.state_;
-  other_impl.state_ = 0;
-
-  reactor_.move_descriptor(impl.descriptor_,
-      impl.reactor_data_, other_impl.reactor_data_);
-}
-
-void reactive_descriptor_service::move_assign(
-    reactive_descriptor_service::implementation_type& impl,
-    reactive_descriptor_service& other_service,
-    reactive_descriptor_service::implementation_type& other_impl)
-{
-  destroy(impl);
-
-  impl.descriptor_ = other_impl.descriptor_;
-  other_impl.descriptor_ = -1;
-
-  impl.state_ = other_impl.state_;
-  other_impl.state_ = 0;
-
-  other_service.reactor_.move_descriptor(impl.descriptor_,
-      impl.reactor_data_, other_impl.reactor_data_);
-}
-
 void reactive_descriptor_service::destroy(
     reactive_descriptor_service::implementation_type& impl)
 {
   if (is_open(impl))
-  {
-    BOOST_ASIO_HANDLER_OPERATION(("descriptor", &impl, "close"));
-
-    reactor_.deregister_descriptor(impl.descriptor_, impl.reactor_data_,
-        (impl.state_ & descriptor_ops::possible_dup) == 0);
-  }
+    reactor_.close_descriptor(impl.descriptor_, impl.reactor_data_);
 
   boost::system::error_code ignored_ec;
   descriptor_ops::close(impl.descriptor_, impl.state_, ignored_ec);
 }
 
 boost::system::error_code reactive_descriptor_service::assign(
     reactive_descriptor_service::implementation_type& impl,
-    const native_handle_type& native_descriptor, boost::system::error_code& ec)
+    const native_type& native_descriptor, boost::system::error_code& ec)
 {
   if (is_open(impl))
   {
     ec = boost::asio::error::already_open;
     return ec;
   }
 
   if (int err = reactor_.register_descriptor(
         native_descriptor, impl.reactor_data_))
   {
     ec = boost::system::error_code(err,
         boost::asio::error::get_system_category());
     return ec;
   }
 
   impl.descriptor_ = native_descriptor;
-  impl.state_ = descriptor_ops::possible_dup;
+  impl.state_ = 0;
   ec = boost::system::error_code();
   return ec;
 }
 
 boost::system::error_code reactive_descriptor_service::close(
     reactive_descriptor_service::implementation_type& impl,
     boost::system::error_code& ec)
 {
   if (is_open(impl))
-  {
-    BOOST_ASIO_HANDLER_OPERATION(("descriptor", &impl, "close"));
-
-    reactor_.deregister_descriptor(impl.descriptor_, impl.reactor_data_,
-        (impl.state_ & descriptor_ops::possible_dup) == 0);
-  }
-
-  descriptor_ops::close(impl.descriptor_, impl.state_, ec);
-
-  // The descriptor is closed by the OS even if close() returns an error.
-  //
-  // (Actually, POSIX says the state of the descriptor is unspecified. On
-  // Linux the descriptor is apparently closed anyway; e.g. see
-  //   http://lkml.org/lkml/2005/9/10/129
-  // We'll just have to assume that other OSes follow the same behaviour.)
-  construct(impl);
+    reactor_.close_descriptor(impl.descriptor_, impl.reactor_data_);
 
-  return ec;
-}
-
-reactive_descriptor_service::native_handle_type
-reactive_descriptor_service::release(
-    reactive_descriptor_service::implementation_type& impl)
-{
-  native_handle_type descriptor = impl.descriptor_;
-
-  if (is_open(impl))
-  {
-    BOOST_ASIO_HANDLER_OPERATION(("descriptor", &impl, "release"));
-
-    reactor_.deregister_descriptor(impl.descriptor_, impl.reactor_data_, false);
+  if (descriptor_ops::close(impl.descriptor_, impl.state_, ec) == 0)
     construct(impl);
-  }
 
-  return descriptor;
+  return ec;
 }
 
 boost::system::error_code reactive_descriptor_service::cancel(
     reactive_descriptor_service::implementation_type& impl,
     boost::system::error_code& ec)
 {
   if (!is_open(impl))
   {
     ec = boost::asio::error::bad_descriptor;
     return ec;
   }
 
-  BOOST_ASIO_HANDLER_OPERATION(("descriptor", &impl, "cancel"));
-
   reactor_.cancel_ops(impl.descriptor_, impl.reactor_data_);
   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 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_))
+          impl.descriptor_, impl.state_, op->ec_))
     {
       reactor_.start_op(op_type, impl.descriptor_,
-          impl.reactor_data_, op, is_non_blocking);
+          impl.reactor_data_, op, non_blocking);
       return;
     }
   }
 
   reactor_.post_immediate_completion(op);
 }
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // !defined(BOOST_WINDOWS) && !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..ece61d3 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,40 +1,40 @@
 //
 // detail/impl/reactive_serial_port_service.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2011 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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_IMPL_REACTIVE_SERIAL_PORT_SERVICE_IPP
 #define BOOST_ASIO_DETAIL_IMPL_REACTIVE_SERIAL_PORT_SERVICE_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_HAS_SERIAL_PORT)
 #if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
 
 #include <cstring>
 #include <boost/asio/detail/reactive_serial_port_service.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 reactive_serial_port_service::reactive_serial_port_service(
     boost::asio::io_service& io_service)
   : descriptor_service_(io_service)
 {
 }
 
 void reactive_serial_port_service::shutdown_service()
 {
@@ -81,73 +81,73 @@ boost::system::error_code reactive_serial_port_service::open(
     ios.c_oflag &= ~OPOST;
     ios.c_lflag &= ~(ECHO | ECHONL | ICANON | ISIG | IEXTEN);
     ios.c_cflag &= ~(CSIZE | PARENB);
     ios.c_cflag |= CS8;
 #endif
     ios.c_iflag |= IGNPAR;
     ios.c_cflag |= CREAD | CLOCAL;
     errno = 0;
     s = descriptor_ops::error_wrapper(::tcsetattr(fd, TCSANOW, &ios), ec);
   }
   if (s < 0)
   {
     boost::system::error_code ignored_ec;
     descriptor_ops::close(fd, state, ignored_ec);
     return ec;
   }
 
   // We're done. Take ownership of the serial port descriptor.
   if (descriptor_service_.assign(impl, fd, ec))
   {
     boost::system::error_code ignored_ec;
     descriptor_ops::close(fd, state, ignored_ec);
   }
 
   return ec;
 }
 
 boost::system::error_code reactive_serial_port_service::do_set_option(
     reactive_serial_port_service::implementation_type& impl,
     reactive_serial_port_service::store_function_type store,
     const void* option, boost::system::error_code& ec)
 {
   termios ios;
   errno = 0;
   descriptor_ops::error_wrapper(::tcgetattr(
-        descriptor_service_.native_handle(impl), &ios), ec);
+        descriptor_service_.native(impl), &ios), ec);
   if (ec)
     return ec;
 
   if (store(option, ios, ec))
     return ec;
 
   errno = 0;
   descriptor_ops::error_wrapper(::tcsetattr(
-        descriptor_service_.native_handle(impl), TCSANOW, &ios), ec);
+        descriptor_service_.native(impl), TCSANOW, &ios), ec);
   return ec;
 }
 
 boost::system::error_code reactive_serial_port_service::do_get_option(
     const reactive_serial_port_service::implementation_type& impl,
     reactive_serial_port_service::load_function_type load,
     void* option, boost::system::error_code& ec) const
 {
   termios ios;
   errno = 0;
   descriptor_ops::error_wrapper(::tcgetattr(
-        descriptor_service_.native_handle(impl), &ios), ec);
+        descriptor_service_.native(impl), &ios), ec);
   if (ec)
     return ec;
 
   return load(option, ios, ec);
 }
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // !defined(BOOST_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..31f5bc4 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,265 +1,214 @@
 //
 // detail/reactive_socket_service_base.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_IMPL_REACTIVE_SOCKET_SERVICE_BASE_IPP
 #define BOOST_ASIO_DETAIL_IMPL_REACTIVE_SOCKET_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_HAS_IOCP)
 
 #include <boost/asio/detail/reactive_socket_service_base.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 reactive_socket_service_base::reactive_socket_service_base(
     boost::asio::io_service& io_service)
   : reactor_(use_service<reactor>(io_service))
 {
   reactor_.init_task();
 }
 
 void reactive_socket_service_base::shutdown_service()
 {
 }
 
 void reactive_socket_service_base::construct(
     reactive_socket_service_base::base_implementation_type& impl)
 {
   impl.socket_ = invalid_socket;
   impl.state_ = 0;
 }
 
-void reactive_socket_service_base::base_move_construct(
-    reactive_socket_service_base::base_implementation_type& impl,
-    reactive_socket_service_base::base_implementation_type& other_impl)
-{
-  impl.socket_ = other_impl.socket_;
-  other_impl.socket_ = invalid_socket;
-
-  impl.state_ = other_impl.state_;
-  other_impl.state_ = 0;
-
-  reactor_.move_descriptor(impl.socket_,
-      impl.reactor_data_, other_impl.reactor_data_);
-}
-
-void reactive_socket_service_base::base_move_assign(
-    reactive_socket_service_base::base_implementation_type& impl,
-    reactive_socket_service_base& other_service,
-    reactive_socket_service_base::base_implementation_type& other_impl)
-{
-  destroy(impl);
-
-  impl.socket_ = other_impl.socket_;
-  other_impl.socket_ = invalid_socket;
-
-  impl.state_ = other_impl.state_;
-  other_impl.state_ = 0;
-
-  other_service.reactor_.move_descriptor(impl.socket_,
-      impl.reactor_data_, other_impl.reactor_data_);
-}
-
 void reactive_socket_service_base::destroy(
     reactive_socket_service_base::base_implementation_type& impl)
 {
   if (impl.socket_ != invalid_socket)
   {
-    BOOST_ASIO_HANDLER_OPERATION(("socket", &impl, "close"));
-
-    reactor_.deregister_descriptor(impl.socket_, impl.reactor_data_,
-        (impl.state_ & socket_ops::possible_dup) == 0);
+    reactor_.close_descriptor(impl.socket_, impl.reactor_data_);
 
     boost::system::error_code ignored_ec;
     socket_ops::close(impl.socket_, impl.state_, true, ignored_ec);
   }
 }
 
 boost::system::error_code reactive_socket_service_base::close(
     reactive_socket_service_base::base_implementation_type& impl,
     boost::system::error_code& ec)
 {
   if (is_open(impl))
-  {
-    BOOST_ASIO_HANDLER_OPERATION(("socket", &impl, "close"));
+    reactor_.close_descriptor(impl.socket_, impl.reactor_data_);
 
-    reactor_.deregister_descriptor(impl.socket_, impl.reactor_data_,
-        (impl.state_ & socket_ops::possible_dup) == 0);
-  }
-
-  socket_ops::close(impl.socket_, impl.state_, false, ec);
-
-  // The descriptor is closed by the OS even if close() returns an error.
-  //
-  // (Actually, POSIX says the state of the descriptor is unspecified. On
-  // Linux the descriptor is apparently closed anyway; e.g. see
-  //   http://lkml.org/lkml/2005/9/10/129
-  // We'll just have to assume that other OSes follow the same behaviour. The
-  // known exception is when Windows's closesocket() function fails with
-  // WSAEWOULDBLOCK, but this case is handled inside socket_ops::close().
-  construct(impl);
+  if (socket_ops::close(impl.socket_, impl.state_, false, ec) == 0)
+    construct(impl);
 
   return ec;
 }
 
 boost::system::error_code reactive_socket_service_base::cancel(
     reactive_socket_service_base::base_implementation_type& impl,
     boost::system::error_code& ec)
 {
   if (!is_open(impl))
   {
     ec = boost::asio::error::bad_descriptor;
     return ec;
   }
 
-  BOOST_ASIO_HANDLER_OPERATION(("socket", &impl, "cancel"));
-
   reactor_.cancel_ops(impl.socket_, impl.reactor_data_);
   ec = boost::system::error_code();
   return ec;
 }
 
 boost::system::error_code reactive_socket_service_base::do_open(
     reactive_socket_service_base::base_implementation_type& impl,
     int af, int type, int protocol, boost::system::error_code& ec)
 {
   if (is_open(impl))
   {
     ec = boost::asio::error::already_open;
     return ec;
   }
 
   socket_holder sock(socket_ops::socket(af, type, protocol, ec));
   if (sock.get() == invalid_socket)
     return ec;
 
   if (int err = reactor_.register_descriptor(sock.get(), impl.reactor_data_))
   {
     ec = boost::system::error_code(err,
         boost::asio::error::get_system_category());
     return ec;
   }
 
   impl.socket_ = sock.release();
   switch (type)
   {
   case SOCK_STREAM: impl.state_ = socket_ops::stream_oriented; break;
   case SOCK_DGRAM: impl.state_ = socket_ops::datagram_oriented; break;
   default: impl.state_ = 0; break;
   }
   ec = boost::system::error_code();
   return ec;
 }
 
 boost::system::error_code reactive_socket_service_base::do_assign(
     reactive_socket_service_base::base_implementation_type& impl, int type,
-    const reactive_socket_service_base::native_handle_type& native_socket,
+    const reactive_socket_service_base::native_type& native_socket,
     boost::system::error_code& ec)
 {
   if (is_open(impl))
   {
     ec = boost::asio::error::already_open;
     return ec;
   }
 
   if (int err = reactor_.register_descriptor(
         native_socket, impl.reactor_data_))
   {
     ec = boost::system::error_code(err,
         boost::asio::error::get_system_category());
     return ec;
   }
 
   impl.socket_ = native_socket;
   switch (type)
   {
   case SOCK_STREAM: impl.state_ = socket_ops::stream_oriented; break;
   case SOCK_DGRAM: impl.state_ = socket_ops::datagram_oriented; break;
   default: impl.state_ = 0; break;
   }
-  impl.state_ |= socket_ops::possible_dup;
   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 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_))
+          impl.socket_, impl.state_, op->ec_))
     {
       reactor_.start_op(op_type, impl.socket_,
-          impl.reactor_data_, op, is_non_blocking);
+          impl.reactor_data_, op, non_blocking);
       return;
     }
   }
 
   reactor_.post_immediate_completion(op);
 }
 
 void reactive_socket_service_base::start_accept_op(
     reactive_socket_service_base::base_implementation_type& impl,
     reactor_op* op, bool peer_is_open)
 {
   if (!peer_is_open)
     start_op(impl, reactor::read_op, op, true, false);
   else
   {
     op->ec_ = boost::asio::error::already_open;
     reactor_.post_immediate_completion(op);
   }
 }
 
 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)
 {
   if ((impl.state_ & socket_ops::non_blocking)
       || socket_ops::set_internal_non_blocking(
-        impl.socket_, impl.state_, true, op->ec_))
+        impl.socket_, impl.state_, 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);
         return;
       }
     }
   }
 
   reactor_.post_immediate_completion(op);
 }
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // !defined(BOOST_ASIO_HAS_IOCP)
 
 #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..e456bb9 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,132 +1,108 @@
 //
 // detail/impl/resolver_service_base.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_IMPL_RESOLVER_SERVICE_BASE_IPP
 #define BOOST_ASIO_DETAIL_IMPL_RESOLVER_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>
 #include <boost/asio/detail/resolver_service_base.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 class resolver_service_base::work_io_service_runner
 {
 public:
   work_io_service_runner(boost::asio::io_service& io_service)
     : io_service_(io_service) {}
   void operator()() { io_service_.run(); }
 private:
   boost::asio::io_service& io_service_;
 };
 
 resolver_service_base::resolver_service_base(
     boost::asio::io_service& io_service)
   : io_service_impl_(boost::asio::use_service<io_service_impl>(io_service)),
     work_io_service_(new boost::asio::io_service),
     work_io_service_impl_(boost::asio::use_service<
         io_service_impl>(*work_io_service_)),
     work_(new boost::asio::io_service::work(*work_io_service_)),
     work_thread_(0)
 {
 }
 
 resolver_service_base::~resolver_service_base()
 {
   shutdown_service();
 }
 
 void resolver_service_base::shutdown_service()
 {
   work_.reset();
-  if (work_io_service_.get())
+  if (work_io_service_)
   {
     work_io_service_->stop();
-    if (work_thread_.get())
+    if (work_thread_)
     {
       work_thread_->join();
       work_thread_.reset();
     }
     work_io_service_.reset();
   }
 }
 
-void resolver_service_base::fork_service(
-    boost::asio::io_service::fork_event fork_ev)
-{
-  if (work_thread_.get())
-  {
-    if (fork_ev == boost::asio::io_service::fork_prepare)
-    {
-      work_io_service_->stop();
-      work_thread_->join();
-    }
-    else
-    {
-      work_io_service_->reset();
-      work_thread_.reset(new boost::asio::detail::thread(
-            work_io_service_runner(*work_io_service_)));
-    }
-  }
-}
-
 void resolver_service_base::construct(
     resolver_service_base::implementation_type& impl)
 {
   impl.reset(static_cast<void*>(0), socket_ops::noop_deleter());
 }
 
 void resolver_service_base::destroy(
-    resolver_service_base::implementation_type& impl)
+    resolver_service_base::implementation_type&)
 {
-  BOOST_ASIO_HANDLER_OPERATION(("resolver", &impl, "cancel"));
-
-  impl.reset();
 }
 
 void resolver_service_base::cancel(
     resolver_service_base::implementation_type& impl)
 {
-  BOOST_ASIO_HANDLER_OPERATION(("resolver", &impl, "cancel"));
-
   impl.reset(static_cast<void*>(0), socket_ops::noop_deleter());
 }
 
 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);
 }
 
 void resolver_service_base::start_work_thread()
 {
   boost::asio::detail::mutex::scoped_lock lock(mutex_);
-  if (!work_thread_.get())
+  if (!work_thread_)
   {
     work_thread_.reset(new boost::asio::detail::thread(
           work_io_service_runner(*work_io_service_)));
   }
 }
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // BOOST_ASIO_DETAIL_IMPL_RESOLVER_SERVICE_BASE_IPP
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..3773bfb 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/select_reactor.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/select_reactor.hpp
@@ -1,87 +1,86 @@
 //
 // detail/impl/select_reactor.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_IMPL_SELECT_REACTOR_HPP
 #define BOOST_ASIO_DETAIL_IMPL_SELECT_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_HAS_IOCP) \
   || (!defined(BOOST_ASIO_HAS_DEV_POLL) \
       && !defined(BOOST_ASIO_HAS_EPOLL) \
       && !defined(BOOST_ASIO_HAS_KQUEUE))
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 template <typename Time_Traits>
 void select_reactor::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 select_reactor::remove_timer_queue(timer_queue<Time_Traits>& queue)
 {
   do_remove_timer_queue(queue);
 }
 
 template <typename Time_Traits>
 void select_reactor::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)
+    typename timer_queue<Time_Traits>::per_timer_data& timer, timer_op* op)
 {
   boost::asio::detail::mutex::scoped_lock lock(mutex_);
 
   if (shutdown_)
   {
     io_service_.post_immediate_completion(op);
     return;
   }
 
   bool earliest = queue.enqueue_timer(time, timer, op);
   io_service_.work_started();
   if (earliest)
     interrupter_.interrupt();
 }
 
 template <typename Time_Traits>
 std::size_t select_reactor::cancel_timer(timer_queue<Time_Traits>& queue,
-    typename timer_queue<Time_Traits>::per_timer_data& timer,
-    std::size_t max_cancelled)
+    typename timer_queue<Time_Traits>::per_timer_data& timer)
 {
   boost::asio::detail::mutex::scoped_lock lock(mutex_);
   op_queue<operation> ops;
-  std::size_t n = queue.cancel_timer(timer, ops, max_cancelled);
+  std::size_t n = queue.cancel_timer(timer, ops);
   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_HAS_IOCP)
        //   || (!defined(BOOST_ASIO_HAS_DEV_POLL)
        //       && !defined(BOOST_ASIO_HAS_EPOLL)
        //       && !defined(BOOST_ASIO_HAS_KQUEUE))
 
 #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..8fcf68e 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/select_reactor.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/select_reactor.ipp
@@ -1,40 +1,40 @@
 //
 // detail/impl/select_reactor.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_IMPL_SELECT_REACTOR_IPP
 #define BOOST_ASIO_DETAIL_IMPL_SELECT_REACTOR_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_HAS_IOCP) \
   || (!defined(BOOST_ASIO_HAS_DEV_POLL) \
       && !defined(BOOST_ASIO_HAS_EPOLL) \
       && !defined(BOOST_ASIO_HAS_KQUEUE))
 
 #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>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 select_reactor::select_reactor(boost::asio::io_service& io_service)
   : boost::asio::detail::service_base<select_reactor>(io_service),
     io_service_(use_service<io_service_impl>(io_service)),
     mutex_(),
@@ -50,224 +50,185 @@ select_reactor::select_reactor(boost::asio::io_service& io_service)
   thread_ = new boost::asio::detail::thread(
       bind_handler(&select_reactor::call_run_thread, this));
 #endif // defined(BOOST_ASIO_HAS_IOCP)
 }
 
 select_reactor::~select_reactor()
 {
   shutdown_service();
 }
 
 void select_reactor::shutdown_service()
 {
   boost::asio::detail::mutex::scoped_lock lock(mutex_);
   shutdown_ = true;
 #if defined(BOOST_ASIO_HAS_IOCP)
   stop_thread_ = true;
 #endif // defined(BOOST_ASIO_HAS_IOCP)
   lock.unlock();
 
 #if defined(BOOST_ASIO_HAS_IOCP)
   if (thread_)
   {
     interrupter_.interrupt();
     thread_->join();
     delete thread_;
     thread_ = 0;
   }
 #endif // defined(BOOST_ASIO_HAS_IOCP)
 
   op_queue<operation> ops;
 
   for (int i = 0; i < max_ops; ++i)
     op_queue_[i].get_all_operations(ops);
 
   timer_queues_.get_all_timers(ops);
-
-  io_service_.abandon_operations(ops);
-}
-
-void select_reactor::fork_service(boost::asio::io_service::fork_event fork_ev)
-{
-  if (fork_ev == boost::asio::io_service::fork_child)
-    interrupter_.recreate();
 }
 
 void select_reactor::init_task()
 {
   io_service_.init_task();
 }
 
 int select_reactor::register_descriptor(socket_type,
     select_reactor::per_descriptor_data&)
 {
   return 0;
 }
 
-int select_reactor::register_internal_descriptor(
-    int op_type, socket_type descriptor,
-    select_reactor::per_descriptor_data&, reactor_op* op)
-{
-  boost::asio::detail::mutex::scoped_lock lock(mutex_);
-
-  op_queue_[op_type].enqueue_operation(descriptor, op);
-  interrupter_.interrupt();
-
-  return 0;
-}
-
-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)
 {
   boost::asio::detail::mutex::scoped_lock lock(mutex_);
 
   if (shutdown_)
   {
     post_immediate_completion(op);
     return;
   }
 
   bool first = op_queue_[op_type].enqueue_operation(descriptor, op);
   io_service_.work_started();
   if (first)
     interrupter_.interrupt();
 }
 
 void select_reactor::cancel_ops(socket_type descriptor,
     select_reactor::per_descriptor_data&)
 {
   boost::asio::detail::mutex::scoped_lock lock(mutex_);
   cancel_ops_unlocked(descriptor, boost::asio::error::operation_aborted);
 }
 
-void select_reactor::deregister_descriptor(socket_type descriptor,
-    select_reactor::per_descriptor_data&, bool)
+void select_reactor::close_descriptor(socket_type descriptor,
+    select_reactor::per_descriptor_data&)
 {
   boost::asio::detail::mutex::scoped_lock lock(mutex_);
   cancel_ops_unlocked(descriptor, boost::asio::error::operation_aborted);
 }
 
-void select_reactor::deregister_internal_descriptor(
-    socket_type descriptor, select_reactor::per_descriptor_data&)
-{
-  boost::asio::detail::mutex::scoped_lock lock(mutex_);
-  op_queue<operation> ops;
-  for (int i = 0; i < max_ops; ++i)
-    op_queue_[i].cancel_operations(descriptor, ops);
-}
-
 void select_reactor::run(bool block, op_queue<operation>& ops)
 {
   boost::asio::detail::mutex::scoped_lock lock(mutex_);
 
 #if defined(BOOST_ASIO_HAS_IOCP)
   // Check if the thread is supposed to stop.
   if (stop_thread_)
     return;
 #endif // defined(BOOST_ASIO_HAS_IOCP)
 
   // Set up the descriptor sets.
-  for (int i = 0; i < max_select_ops; ++i)
-    fd_sets_[i].reset();
-  fd_sets_[read_op].set(interrupter_.read_descriptor());
+  fd_set_adapter fds[max_select_ops];
+  fds[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);
-    if (fd_sets_[i].max_descriptor() > max_fd)
-      max_fd = fd_sets_[i].max_descriptor();
+    op_queue_[i].get_descriptors(fds[i], ops);
+    if (fds[i].max_descriptor() > max_fd)
+      max_fd = fds[i].max_descriptor();
   }
 
 #if defined(BOOST_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);
-  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);
-  if (fd_sets_[except_op].max_descriptor() > max_fd)
-    max_fd = fd_sets_[except_op].max_descriptor();
+  op_queue_[connect_op].get_descriptors(fds[write_op], ops);
+  if (fds[write_op].max_descriptor() > max_fd)
+    max_fd = fds[write_op].max_descriptor();
+  op_queue_[connect_op].get_descriptors(fds[except_op], ops);
+  if (fds[except_op].max_descriptor() > max_fd)
+    max_fd = fds[except_op].max_descriptor();
 #endif // defined(BOOST_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;
 
   // Determine how long to block while waiting for events.
   timeval tv_buf = { 0, 0 };
   timeval* tv = block ? get_timeout(tv_buf) : &tv_buf;
 
   lock.unlock();
 
   // Block on the select call until descriptors become ready.
   boost::system::error_code ec;
   int retval = socket_ops::select(static_cast<int>(max_fd + 1),
-      fd_sets_[read_op], fd_sets_[write_op], fd_sets_[except_op], tv, ec);
+      fds[read_op], fds[write_op], fds[except_op], tv, ec);
 
   // Reset the interrupter.
-  if (retval > 0 && fd_sets_[read_op].is_set(interrupter_.read_descriptor()))
-  {
+  if (retval > 0 && fds[read_op].is_set(interrupter_.read_descriptor()))
     interrupter_.reset();
-    --retval;
-  }
 
   lock.lock();
 
   // Dispatch all ready operations.
   if (retval > 0)
   {
 #if defined(BOOST_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);
+        fds[except_op], ops);
     op_queue_[connect_op].perform_operations_for_descriptors(
-        fd_sets_[write_op], ops);
+        fds[write_op], ops);
 #endif // defined(BOOST_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);
+      op_queue_[i].perform_operations_for_descriptors(fds[i], ops);
   }
   timer_queues_.get_ready_timers(ops);
 }
 
 void select_reactor::interrupt()
 {
   interrupter_.interrupt();
 }
 
 #if defined(BOOST_ASIO_HAS_IOCP)
 void select_reactor::run_thread()
 {
   boost::asio::detail::mutex::scoped_lock lock(mutex_);
   while (!stop_thread_)
   {
     lock.unlock();
     op_queue<operation> ops;
     run(true, ops);
     io_service_.post_deferred_completions(ops);
     lock.lock();
   }
 }
 
 void select_reactor::call_run_thread(select_reactor* reactor)
 {
   reactor->run_thread();
 }
 #endif // defined(BOOST_ASIO_HAS_IOCP)
 
 void select_reactor::do_add_timer_queue(timer_queue_base& queue)
 {
   mutex::scoped_lock lock(mutex_);
   timer_queues_.insert(&queue);
 }
 
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..97f5771 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/service_registry.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/service_registry.hpp
@@ -1,76 +1,58 @@
 //
 // detail/impl/service_registry.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_IMPL_SERVICE_REGISTRY_HPP
 #define BOOST_ASIO_DETAIL_IMPL_SERVICE_REGISTRY_HPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
-template <typename Service, typename Arg>
-service_registry::service_registry(
-    boost::asio::io_service& o, Service*, Arg arg)
-  : owner_(o),
-    first_service_(new Service(o, arg))
-{
-  boost::asio::io_service::service::key key;
-  init_key(key, Service::id);
-  first_service_->key_ = key;
-  first_service_->next_ = 0;
-}
-
-template <typename Service>
-Service& service_registry::first_service()
-{
-  return *static_cast<Service*>(first_service_);
-}
-
 template <typename Service>
 Service& service_registry::use_service()
 {
   boost::asio::io_service::service::key key;
   init_key(key, Service::id);
   factory_type factory = &service_registry::create<Service>;
   return *static_cast<Service*>(do_use_service(key, factory));
 }
 
 template <typename Service>
 void service_registry::add_service(Service* new_service)
 {
   boost::asio::io_service::service::key key;
   init_key(key, Service::id);
   return do_add_service(key, new_service);
 }
 
 template <typename Service>
 bool service_registry::has_service() const
 {
   boost::asio::io_service::service::key key;
   init_key(key, Service::id);
   return do_has_service(key);
 }
 
 #if !defined(BOOST_ASIO_NO_TYPEID)
 template <typename Service>
 void service_registry::init_key(boost::asio::io_service::service::key& key,
     const boost::asio::detail::service_id<Service>& /*id*/)
 {
   key.type_info_ = &typeid(typeid_wrapper<Service>);
   key.id_ = 0;
 }
 #endif // !defined(BOOST_ASIO_NO_TYPEID)
 
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..c2f07ec 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/service_registry.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/service_registry.ipp
@@ -1,183 +1,159 @@
 //
 // detail/impl/service_registry.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_IMPL_SERVICE_REGISTRY_IPP
 #define BOOST_ASIO_DETAIL_IMPL_SERVICE_REGISTRY_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/throw_exception.hpp>
-#include <vector>
 #include <boost/asio/detail/service_registry.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
+service_registry::service_registry(boost::asio::io_service& o)
+  : owner_(o),
+    first_service_(0)
+{
+}
+
 service_registry::~service_registry()
 {
   // Shutdown all services. This must be done in a separate loop before the
   // services are destroyed since the destructors of user-defined handler
   // objects may try to access other service objects.
   boost::asio::io_service::service* service = first_service_;
   while (service)
   {
     service->shutdown_service();
     service = service->next_;
   }
 
   // Destroy all services.
   while (first_service_)
   {
     boost::asio::io_service::service* next_service = first_service_->next_;
     destroy(first_service_);
     first_service_ = next_service;
   }
 }
 
-void service_registry::notify_fork(boost::asio::io_service::fork_event fork_ev)
-{
-  // Make a copy of all of the services while holding the lock. We don't want
-  // to hold the lock while calling into each service, as it may try to call
-  // back into this class.
-  std::vector<boost::asio::io_service::service*> services;
-  {
-    boost::asio::detail::mutex::scoped_lock lock(mutex_);
-    boost::asio::io_service::service* service = first_service_;
-    while (service)
-    {
-      services.push_back(service);
-      service = service->next_;
-    }
-  }
-
-  // If processing the fork_prepare event, we want to go in reverse order of
-  // service registration, which happens to be the existing order of the
-  // services in the vector. For the other events we want to go in the other
-  // direction.
-  std::size_t num_services = services.size();
-  if (fork_ev == boost::asio::io_service::fork_prepare)
-    for (std::size_t i = 0; i < num_services; ++i)
-      services[i]->fork_service(fork_ev);
-  else
-    for (std::size_t i = num_services; i > 0; --i)
-      services[i - 1]->fork_service(fork_ev);
-}
-
 void service_registry::init_key(boost::asio::io_service::service::key& key,
     const boost::asio::io_service::id& id)
 {
   key.type_info_ = 0;
   key.id_ = &id;
 }
 
 bool service_registry::keys_match(
     const boost::asio::io_service::service::key& key1,
     const boost::asio::io_service::service::key& key2)
 {
   if (key1.id_ && key2.id_)
     if (key1.id_ == key2.id_)
       return true;
   if (key1.type_info_ && key2.type_info_)
     if (*key1.type_info_ == *key2.type_info_)
       return true;
   return false;
 }
 
 void service_registry::destroy(boost::asio::io_service::service* service)
 {
   delete service;
 }
 
 boost::asio::io_service::service* service_registry::do_use_service(
     const boost::asio::io_service::service::key& key,
     factory_type factory)
 {
   boost::asio::detail::mutex::scoped_lock lock(mutex_);
 
   // First see 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))
       return service;
     service = service->next_;
   }
 
   // Create a new service object. The service registry's mutex is not locked
   // at this time to allow for nested calls into this function from the new
   // service's constructor.
   lock.unlock();
   auto_service_ptr new_service = { factory(owner_) };
   new_service.ptr_->key_ = key;
   lock.lock();
 
   // Check that nobody else created another service object of the same type
   // while the lock was released.
   service = first_service_;
   while (service)
   {
     if (keys_match(service->key_, key))
       return service;
     service = service->next_;
   }
 
   // Service was successfully initialised, pass ownership to registry.
   new_service.ptr_->next_ = first_service_;
   first_service_ = new_service.ptr_;
   new_service.ptr_ = 0;
   return first_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())
+  if (&owner_ != &new_service->io_service())
     boost::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());
     service = service->next_;
   }
 
   // Take ownership of the service object.
   new_service->key_ = key;
   new_service->next_ = first_service_;
   first_service_ = new_service;
 }
 
 bool service_registry::do_has_service(
     const boost::asio::io_service::service::key& key) const
 {
   boost::asio::detail::mutex::scoped_lock lock(mutex_);
 
   boost::asio::io_service::service* service = first_service_;
   while (service)
   {
     if (keys_match(service->key_, key))
       return true;
     service = service->next_;
   }
 
   return false;
 }
 
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
deleted file mode 100644
index 0b57007..0000000
--- a/3rdParty/Boost/src/boost/asio/detail/impl/signal_set_service.ipp
+++ /dev/null
@@ -1,593 +0,0 @@
-//
-// detail/impl/signal_set_service.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// 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_IMPL_SIGNAL_SET_SERVICE_IPP
-#define BOOST_ASIO_DETAIL_IMPL_SIGNAL_SET_SERVICE_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 <boost/asio/detail/reactor.hpp>
-#include <boost/asio/detail/signal_blocker.hpp>
-#include <boost/asio/detail/signal_set_service.hpp>
-#include <boost/asio/detail/static_mutex.hpp>
-
-#include <boost/asio/detail/push_options.hpp>
-
-namespace boost {
-namespace asio {
-namespace detail {
-
-struct signal_state
-{
-  // Mutex used for protecting global state.
-  static_mutex mutex_;
-
-  // The read end of the pipe used for signal notifications.
-  int read_descriptor_;
-
-  // The write end of the pipe used for signal notifications.
-  int write_descriptor_;
-
-  // Whether the signal state has been prepared for a fork.
-  bool fork_prepared_;
-
-  // The head of a linked list of all signal_set_service instances.
-  class signal_set_service* service_list_;
-
-  // A count of the number of objects that are registered for each signal.
-  std::size_t registration_count_[max_signal_number];
-};
-
-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)
-{
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
-  signal_set_service::deliver_signal(signal_number);
-#else // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
-  int saved_errno = errno;
-  signal_state* state = get_signal_state();
-  int result = ::write(state->write_descriptor_,
-      &signal_number, sizeof(signal_number));
-  (void)result;
-  errno = saved_errno;
-#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
-
-#if defined(BOOST_ASIO_HAS_SIGNAL) && !defined(BOOST_ASIO_HAS_SIGACTION)
-  ::signal(signal_number, asio_signal_handler);
-#endif // defined(BOOST_ASIO_HAS_SIGNAL) && !defined(BOOST_ASIO_HAS_SIGACTION)
-}
-
-#if !defined(BOOST_WINDOWS) && !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)
-  {
-  }
-
-  static bool do_perform(reactor_op*)
-  {
-    signal_state* state = get_signal_state();
-
-    int fd = state->read_descriptor_;
-    int signal_number = 0;
-    while (::read(fd, &signal_number, sizeof(int)) == sizeof(int))
-      if (signal_number >= 0 && signal_number < max_signal_number)
-        signal_set_service::deliver_signal(signal_number);
-
-    return false;
-  }
-
-  static void do_complete(io_service_impl* /*owner*/, operation* base,
-      const boost::system::error_code& /*ec*/,
-      std::size_t /*bytes_transferred*/)
-  {
-    pipe_read_op* o(static_cast<pipe_read_op*>(base));
-    delete o;
-  }
-};
-#endif // !defined(BOOST_WINDOWS) && !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__)
-    reactor_(boost::asio::use_service<reactor>(io_service)),
-#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
-    next_(0),
-    prev_(0)
-{
-  get_signal_state()->mutex_.init();
-
-#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
-  reactor_.init_task();
-#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
-
-  for (int i = 0; i < max_signal_number; ++i)
-    registrations_[i] = 0;
-
-  add_service(this);
-}
-
-signal_set_service::~signal_set_service()
-{
-  remove_service(this);
-}
-
-void signal_set_service::shutdown_service()
-{
-  remove_service(this);
-
-  op_queue<operation> ops;
-
-  for (int i = 0; i < max_signal_number; ++i)
-  {
-    registration* reg = registrations_[i];
-    while (reg)
-    {
-      ops.push(*reg->queue_);
-      reg = reg->next_in_table_;
-    }
-  }
-
-  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__)
-  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;
-    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);
-    break;
-  case boost::asio::io_service::fork_child:
-    if (state->fork_prepared_)
-    {
-      boost::asio::detail::signal_blocker blocker;
-      close_descriptors();
-      open_descriptors();
-      state->fork_prepared_ = false;
-    }
-    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__)
-  (void)fork_ev;
-#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
-}
-
-void signal_set_service::construct(
-    signal_set_service::implementation_type& impl)
-{
-  impl.signals_ = 0;
-}
-
-void signal_set_service::destroy(
-    signal_set_service::implementation_type& impl)
-{
-  boost::system::error_code ignored_ec;
-  clear(impl, ignored_ec);
-  cancel(impl, ignored_ec);
-}
-
-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)
-  {
-    ec = boost::asio::error::invalid_argument;
-    return ec;
-  }
-
-  signal_state* state = get_signal_state();
-  static_mutex::scoped_lock lock(state->mutex_);
-
-  // Find the appropriate place to insert the registration.
-  registration** insertion_point = &impl.signals_;
-  registration* next = impl.signals_;
-  while (next && next->signal_number_ < signal_number)
-  {
-    insertion_point = &next->next_in_set_;
-    next = next->next_in_set_;
-  }
-
-  // Only do something if the signal is not already registered.
-  if (next == 0 || next->signal_number_ != signal_number)
-  {
-    registration* new_registration = new registration;
-
-#if defined(BOOST_ASIO_HAS_SIGNAL) || defined(BOOST_ASIO_HAS_SIGACTION)
-    // Register for the signal if we're the first.
-    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;
-      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)
-# endif // defined(BOOST_ASIO_HAS_SIGACTION)
-      {
-# if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
-        ec = boost::asio::error::invalid_argument;
-# else // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
-        ec = boost::system::error_code(errno,
-            boost::asio::error::get_system_category());
-# endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
-        delete new_registration;
-        return ec;
-      }
-    }
-#endif // defined(BOOST_ASIO_HAS_SIGNAL) || defined(BOOST_ASIO_HAS_SIGACTION)
-
-    // Record the new registration in the set.
-    new_registration->signal_number_ = signal_number;
-    new_registration->queue_ = &impl.queue_;
-    new_registration->next_in_set_ = next;
-    *insertion_point = new_registration;
-
-    // Insert registration into the registration table.
-    new_registration->next_in_table_ = registrations_[signal_number];
-    if (registrations_[signal_number])
-      registrations_[signal_number]->prev_in_table_ = new_registration;
-    registrations_[signal_number] = new_registration;
-
-    ++state->registration_count_[signal_number];
-  }
-
-  ec = boost::system::error_code();
-  return ec;
-}
-
-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)
-  {
-    ec = boost::asio::error::invalid_argument;
-    return ec;
-  }
-
-  signal_state* state = get_signal_state();
-  static_mutex::scoped_lock lock(state->mutex_);
-
-  // Find the signal number in the list of registrations.
-  registration** deletion_point = &impl.signals_;
-  registration* reg = impl.signals_;
-  while (reg && reg->signal_number_ < signal_number)
-  {
-    deletion_point = &reg->next_in_set_;
-    reg = reg->next_in_set_;
-  }
-
-  if (reg != 0 && reg->signal_number_ == signal_number)
-  {
-#if defined(BOOST_ASIO_HAS_SIGNAL) || defined(BOOST_ASIO_HAS_SIGACTION)
-    // Set signal handler back to the default if we're the last.
-    if (state->registration_count_[signal_number] == 1)
-    {
-# if defined(BOOST_ASIO_HAS_SIGACTION)
-      using namespace std; // For memset.
-      struct sigaction sa;
-      memset(&sa, 0, sizeof(sa));
-      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__)
-        ec = boost::asio::error::invalid_argument;
-# else // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
-        ec = boost::system::error_code(errno,
-            boost::asio::error::get_system_category());
-# endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
-        return ec;
-      }
-    }
-#endif // defined(BOOST_ASIO_HAS_SIGNAL) || defined(BOOST_ASIO_HAS_SIGACTION)
-
-    // Remove the registration from the set.
-    *deletion_point = reg->next_in_set_;
-
-    // Remove the registration from the registration table.
-    if (registrations_[signal_number] == reg)
-      registrations_[signal_number] = reg->next_in_table_;
-    if (reg->prev_in_table_)
-      reg->prev_in_table_->next_in_table_ = reg->next_in_table_;
-    if (reg->next_in_table_)
-      reg->next_in_table_->prev_in_table_ = reg->prev_in_table_;
-
-    --state->registration_count_[signal_number];
-
-    delete reg;
-  }
-
-  ec = boost::system::error_code();
-  return ec;
-}
-
-boost::system::error_code signal_set_service::clear(
-    signal_set_service::implementation_type& impl,
-    boost::system::error_code& ec)
-{
-  signal_state* state = get_signal_state();
-  static_mutex::scoped_lock lock(state->mutex_);
-
-  while (registration* reg = impl.signals_)
-  {
-#if defined(BOOST_ASIO_HAS_SIGNAL) || defined(BOOST_ASIO_HAS_SIGACTION)
-    // Set signal handler back to the default if we're the last.
-    if (state->registration_count_[reg->signal_number_] == 1)
-    {
-# if defined(BOOST_ASIO_HAS_SIGACTION)
-      using namespace std; // For memset.
-      struct sigaction sa;
-      memset(&sa, 0, sizeof(sa));
-      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__)
-        ec = boost::asio::error::invalid_argument;
-# else // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
-        ec = boost::system::error_code(errno,
-            boost::asio::error::get_system_category());
-# endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
-        return ec;
-      }
-    }
-#endif // defined(BOOST_ASIO_HAS_SIGNAL) || defined(BOOST_ASIO_HAS_SIGACTION)
-
-    // Remove the registration from the registration table.
-    if (registrations_[reg->signal_number_] == reg)
-      registrations_[reg->signal_number_] = reg->next_in_table_;
-    if (reg->prev_in_table_)
-      reg->prev_in_table_->next_in_table_ = reg->next_in_table_;
-    if (reg->next_in_table_)
-      reg->next_in_table_->prev_in_table_ = reg->prev_in_table_;
-
-    --state->registration_count_[reg->signal_number_];
-
-    impl.signals_ = reg->next_in_set_;
-    delete reg;
-  }
-
-  ec = boost::system::error_code();
-  return ec;
-}
-
-boost::system::error_code signal_set_service::cancel(
-    signal_set_service::implementation_type& impl,
-    boost::system::error_code& ec)
-{
-  BOOST_ASIO_HANDLER_OPERATION(("signal_set", &impl, "cancel"));
-
-  op_queue<operation> ops;
-  {
-    signal_state* state = get_signal_state();
-    static_mutex::scoped_lock lock(state->mutex_);
-
-    while (signal_op* op = impl.queue_.front())
-    {
-      op->ec_ = boost::asio::error::operation_aborted;
-      impl.queue_.pop();
-      ops.push(op);
-    }
-  }
-
-  io_service_.post_deferred_completions(ops);
-
-  ec = boost::system::error_code();
-  return ec;
-}
-
-void signal_set_service::deliver_signal(int signal_number)
-{
-  signal_state* state = get_signal_state();
-  static_mutex::scoped_lock lock(state->mutex_);
-
-  signal_set_service* service = state->service_list_;
-  while (service)
-  {
-    op_queue<operation> ops;
-
-    registration* reg = service->registrations_[signal_number];
-    while (reg)
-    {
-      if (reg->queue_->empty())
-      {
-        ++reg->undelivered_;
-      }
-      else
-      {
-        while (signal_op* op = reg->queue_->front())
-        {
-          op->signal_number_ = signal_number;
-          reg->queue_->pop();
-          ops.push(op);
-        }
-      }
-
-      reg = reg->next_in_table_;
-    }
-
-    service->io_service_.post_deferred_completions(ops);
-
-    service = service->next_;
-  }
-}
-
-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 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__)
-
-  // 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__)
-  // Register for pipe readiness notifications.
-  service->reactor_.register_internal_descriptor(reactor::read_op,
-      state->read_descriptor_, service->reactor_data_, new pipe_read_op);
-#endif // !defined(BOOST_WINDOWS) && !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__)
-    // Disable the pipe readiness notifications.
-    service->reactor_.deregister_descriptor(
-        state->read_descriptor_, service->reactor_data_, false);
-#endif // !defined(BOOST_WINDOWS) && !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 this is the last service to be removed, close the pipe.
-    if (state->service_list_ == 0)
-      close_descriptors();
-#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
-  }
-}
-
-void signal_set_service::open_descriptors()
-{
-#if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
-  signal_state* state = get_signal_state();
-
-  int pipe_fds[2];
-  if (::pipe(pipe_fds) == 0)
-  {
-    state->read_descriptor_ = pipe_fds[0];
-    ::fcntl(state->read_descriptor_, F_SETFL, O_NONBLOCK);
-
-    state->write_descriptor_ = pipe_fds[1];
-    ::fcntl(state->write_descriptor_, F_SETFL, O_NONBLOCK);
-
-#if defined(FD_CLOEXEC)
-    ::fcntl(state->read_descriptor_, F_SETFD, FD_CLOEXEC);
-    ::fcntl(state->write_descriptor_, F_SETFD, FD_CLOEXEC);
-#endif // defined(FD_CLOEXEC)
-  }
-  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__)
-}
-
-void signal_set_service::close_descriptors()
-{
-#if !defined(BOOST_WINDOWS) && !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__)
-}
-
-void signal_set_service::start_wait_op(
-    signal_set_service::implementation_type& impl, signal_op* op)
-{
-  io_service_.work_started();
-
-  signal_state* state = get_signal_state();
-  static_mutex::scoped_lock lock(state->mutex_);
-
-  registration* reg = impl.signals_;
-  while (reg)
-  {
-    if (reg->undelivered_ > 0)
-    {
-      --reg->undelivered_;
-      io_service_.post_deferred_completion(op);
-      return;
-    }
-
-    reg = reg->next_in_set_;
-  }
-
-  impl.queue_.push(op);
-}
-
-} // namespace detail
-} // namespace asio
-} // namespace boost
-
-#include <boost/asio/detail/pop_options.hpp>
-
-#endif // BOOST_ASIO_DETAIL_IMPL_SIGNAL_SET_SERVICE_IPP
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..e240acd 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/socket_ops.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/socket_ops.ipp
@@ -1,56 +1,55 @@
 //
 // detail/impl/socket_ops.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_SOCKET_OPS_IPP
 #define BOOST_ASIO_DETAIL_SOCKET_OPS_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/assert.hpp>
 #include <boost/detail/workaround.hpp>
-#include <cctype>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
 #include <cerrno>
 #include <new>
 #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 {
 namespace socket_ops {
 
 #if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
 struct msghdr { int msg_namelen; };
 #endif // defined(BOOST_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)
 
 inline void clear_last_error()
 {
 #if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
   WSASetLastError(0);
 #else
   errno = 0;
 #endif
 }
 
@@ -117,71 +116,71 @@ socket_type sync_accept(socket_type s, state_type state,
   for (;;)
   {
     // Try to complete the operation without blocking.
     socket_type new_socket = socket_ops::accept(s, addr, addrlen, ec);
 
     // Check if operation succeeded.
     if (new_socket != invalid_socket)
       return new_socket;
 
     // Operation failed.
     if (ec == boost::asio::error::would_block
         || ec == boost::asio::error::try_again)
     {
       if (state & user_set_non_blocking)
         return invalid_socket;
       // Fall through to retry operation.
     }
     else if (ec == boost::asio::error::connection_aborted)
     {
       if (state & enable_connection_aborted)
         return invalid_socket;
       // Fall through to retry operation.
     }
 #if defined(EPROTO)
     else if (ec.value() == EPROTO)
     {
       if (state & enable_connection_aborted)
         return invalid_socket;
       // Fall through to retry operation.
     }
 #endif // defined(EPROTO)
     else
       return invalid_socket;
 
     // Wait for socket to become ready.
-    if (socket_ops::poll_read(s, 0, ec) < 0)
+    if (socket_ops::poll_read(s, ec) < 0)
       return invalid_socket;
   }
 }
 
 #if defined(BOOST_ASIO_HAS_IOCP)
 
 void complete_iocp_accept(socket_type s,
     void* output_buffer, DWORD address_length,
     socket_addr_type* addr, std::size_t* addrlen,
     socket_type new_socket, boost::system::error_code& ec)
 {
   // Map non-portable errors to their portable counterparts.
   if (ec.value() == ERROR_NETNAME_DELETED)
     ec = boost::asio::error::connection_aborted;
 
   if (!ec)
   {
     // Get the address of the peer.
     if (addr && addrlen)
     {
       LPSOCKADDR local_addr = 0;
       int local_addr_length = 0;
       LPSOCKADDR remote_addr = 0;
       int remote_addr_length = 0;
       GetAcceptExSockaddrs(output_buffer, 0, address_length,
           address_length, &local_addr, &local_addr_length,
           &remote_addr, &remote_addr_length);
       if (static_cast<std::size_t>(remote_addr_length) > *addrlen)
       {
         ec = boost::asio::error::invalid_argument;
       }
       else
       {
         using namespace std; // For memcpy.
         memcpy(addr, remote_addr, remote_addr_length);
@@ -247,261 +246,186 @@ bool non_blocking_accept(socket_type s,
   }
 }
 
 #endif // defined(BOOST_ASIO_HAS_IOCP)
 
 template <typename SockLenType>
 inline int call_bind(SockLenType msghdr::*,
     socket_type s, const socket_addr_type* addr, std::size_t addrlen)
 {
   return ::bind(s, addr, (SockLenType)addrlen);
 }
 
 int bind(socket_type s, const socket_addr_type* addr,
     std::size_t addrlen, boost::system::error_code& ec)
 {
   if (s == invalid_socket)
   {
     ec = boost::asio::error::bad_descriptor;
     return socket_error_retval;
   }
 
   clear_last_error();
   int result = error_wrapper(call_bind(
         &msghdr::msg_namelen, s, addr, addrlen), ec);
   if (result == 0)
     ec = boost::system::error_code();
   return result;
 }
 
 int close(socket_type s, state_type& state,
     bool destruction, boost::system::error_code& ec)
 {
   int result = 0;
   if (s != invalid_socket)
   {
-    // We don't want the destructor to block, so set the socket to linger in
-    // the background. If the user doesn't like this behaviour then they need
-    // to explicitly close the socket.
+#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+    if ((state & non_blocking) && (state & user_set_linger))
+    {
+      ioctl_arg_type arg = 0;
+      ::ioctlsocket(s, FIONBIO, &arg);
+      state &= ~non_blocking;
+    }
+#else // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+    if (state & non_blocking)
+    {
+#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__)
+      state &= ~non_blocking;
+    }
+#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
+
     if (destruction && (state & user_set_linger))
     {
       ::linger opt;
       opt.l_onoff = 0;
       opt.l_linger = 0;
       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__)
     result = error_wrapper(::closesocket(s), ec);
 #else // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
     result = error_wrapper(::close(s), ec);
 #endif // defined(BOOST_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__)
-      ioctl_arg_type arg = 0;
-      ::ioctlsocket(s, FIONBIO, &arg);
-#else // defined(BOOST_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__)
-      state &= ~non_blocking;
-
-      clear_last_error();
-#if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
-      result = error_wrapper(::closesocket(s), ec);
-#else // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
-      result = error_wrapper(::close(s), ec);
-#endif // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
-    }
   }
 
   if (result == 0)
     ec = boost::system::error_code();
   return result;
 }
 
-bool set_user_non_blocking(socket_type s,
-    state_type& state, bool value, boost::system::error_code& ec)
-{
-  if (s == invalid_socket)
-  {
-    ec = boost::asio::error::bad_descriptor;
-    return false;
-  }
-
-  clear_last_error();
-#if defined(BOOST_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)
-  {
-    clear_last_error();
-    int flag = (value ? (result | O_NONBLOCK) : (result & ~O_NONBLOCK));
-    result = error_wrapper(::fcntl(s, F_SETFL, flag), ec);
-  }
-#else
-  ioctl_arg_type arg = (value ? 1 : 0);
-  int result = error_wrapper(::ioctl(s, FIONBIO, &arg), ec);
-#endif
-
-  if (result >= 0)
-  {
-    ec = boost::system::error_code();
-    if (value)
-      state |= user_set_non_blocking;
-    else
-    {
-      // Clearing the user-set non-blocking mode always overrides any
-      // internally-set non-blocking flag. Any subsequent asynchronous
-      // operations will need to re-enable non-blocking I/O.
-      state &= ~(user_set_non_blocking | internal_non_blocking);
-    }
-    return true;
-  }
-
-  return false;
-}
-
 bool set_internal_non_blocking(socket_type s,
-    state_type& state, bool value, boost::system::error_code& ec)
+    state_type& state, boost::system::error_code& ec)
 {
   if (s == invalid_socket)
   {
     ec = boost::asio::error::bad_descriptor;
     return false;
   }
 
-  if (!value && (state & user_set_non_blocking))
-  {
-    // It does not make sense to clear the internal non-blocking flag if the
-    // user still wants non-blocking behaviour. Return an error and let the
-    // 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__)
-  ioctl_arg_type arg = (value ? 1 : 0);
+  ioctl_arg_type arg = 1;
   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)
   {
     clear_last_error();
-    int flag = (value ? (result | O_NONBLOCK) : (result & ~O_NONBLOCK));
-    result = error_wrapper(::fcntl(s, F_SETFL, flag), ec);
+    result = error_wrapper(::fcntl(s, F_SETFL, result | O_NONBLOCK), ec);
   }
 #else
-  ioctl_arg_type arg = (value ? 1 : 0);
+  ioctl_arg_type arg = 1;
   int result = error_wrapper(::ioctl(s, FIONBIO, &arg), ec);
 #endif
 
   if (result >= 0)
   {
     ec = boost::system::error_code();
-    if (value)
-      state |= internal_non_blocking;
-    else
-      state &= ~internal_non_blocking;
+    state |= internal_non_blocking;
     return true;
   }
 
   return false;
 }
 
 int shutdown(socket_type s, int what, boost::system::error_code& ec)
 {
   if (s == invalid_socket)
   {
     ec = boost::asio::error::bad_descriptor;
     return socket_error_retval;
   }
 
   clear_last_error();
   int result = error_wrapper(::shutdown(s, what), ec);
   if (result == 0)
     ec = boost::system::error_code();
   return result;
 }
 
 template <typename SockLenType>
 inline int call_connect(SockLenType msghdr::*,
     socket_type s, const socket_addr_type* addr, std::size_t addrlen)
 {
   return ::connect(s, addr, (SockLenType)addrlen);
 }
 
 int connect(socket_type s, const socket_addr_type* addr,
     std::size_t addrlen, boost::system::error_code& ec)
 {
   if (s == invalid_socket)
   {
     ec = boost::asio::error::bad_descriptor;
     return socket_error_retval;
   }
 
   clear_last_error();
   int result = error_wrapper(call_connect(
         &msghdr::msg_namelen, s, addr, addrlen), ec);
   if (result == 0)
     ec = boost::system::error_code();
-#if defined(__linux__)
-  else if (ec == boost::asio::error::try_again)
-    ec = boost::asio::error::no_buffer_space;
-#endif // defined(__linux__)
   return result;
 }
 
 void sync_connect(socket_type s, const socket_addr_type* addr,
     std::size_t addrlen, boost::system::error_code& ec)
 {
   // Perform the connect operation.
   socket_ops::connect(s, addr, addrlen, ec);
   if (ec != boost::asio::error::in_progress
       && ec != boost::asio::error::would_block)
   {
     // The connect operation finished immediately.
     return;
   }
 
   // Wait for socket to become ready.
   if (socket_ops::poll_connect(s, ec) < 0)
     return;
 
   // 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) == socket_error_retval)
     return;
 
   // Return the result of the connect operation.
   ec = boost::system::error_code(connect_error,
       boost::asio::error::get_system_category());
 }
 
 bool non_blocking_connect(socket_type s, boost::system::error_code& ec)
 {
   // Get the error code from the connect operation.
   int connect_error = 0;
@@ -708,71 +632,71 @@ size_t sync_recv(socket_type s, state_type state, buf* bufs,
     ec = boost::asio::error::bad_descriptor;
     return 0;
   }
 
   // A request to read 0 bytes on a stream is a no-op.
   if (all_empty && (state & stream_oriented))
   {
     ec = boost::system::error_code();
     return 0;
   }
 
   // Read some data.
   for (;;)
   {
     // Try to complete the operation without blocking.
     int bytes = socket_ops::recv(s, bufs, count, flags, ec);
 
     // Check if operation succeeded.
     if (bytes > 0)
       return bytes;
 
     // Check for EOF.
     if ((state & stream_oriented) && bytes == 0)
     {
       ec = boost::asio::error::eof;
       return 0;
     }
 
     // Operation failed.
     if ((state & user_set_non_blocking)
         || (ec != boost::asio::error::would_block
           && ec != boost::asio::error::try_again))
       return 0;
 
     // Wait for socket to become ready.
-    if (socket_ops::poll_read(s, 0, ec) < 0)
+    if (socket_ops::poll_read(s, ec) < 0)
       return 0;
   }
 }
 
 #if defined(BOOST_ASIO_HAS_IOCP)
 
 void complete_iocp_recv(state_type state,
     const weak_cancel_token_type& cancel_token, bool all_empty,
     boost::system::error_code& ec, size_t bytes_transferred)
 {
   // Map non-portable errors to their portable counterparts.
   if (ec.value() == ERROR_NETNAME_DELETED)
   {
     if (cancel_token.expired())
       ec = boost::asio::error::operation_aborted;
     else
       ec = boost::asio::error::connection_reset;
   }
   else if (ec.value() == ERROR_PORT_UNREACHABLE)
   {
     ec = boost::asio::error::connection_refused;
   }
 
   // Check for connection closed.
   else if (!ec && bytes_transferred == 0
       && (state & stream_oriented) != 0
       && !all_empty)
   {
     ec = boost::asio::error::eof;
   }
 }
 
 #else // defined(BOOST_ASIO_HAS_IOCP)
 
 bool non_blocking_recv(socket_type s,
@@ -846,308 +770,198 @@ int recvfrom(socket_type s, buf* bufs, size_t count, int flags,
   int 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__)
 }
 
 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 (s == invalid_socket)
   {
     ec = boost::asio::error::bad_descriptor;
     return 0;
   }
 
   // Read some data.
   for (;;)
   {
     // Try to complete the operation without blocking.
     int bytes = socket_ops::recvfrom(s, bufs, count, flags, addr, addrlen, ec);
 
     // Check if operation succeeded.
     if (bytes >= 0)
       return bytes;
 
     // Operation failed.
     if ((state & user_set_non_blocking)
         || (ec != boost::asio::error::would_block
           && ec != boost::asio::error::try_again))
       return 0;
 
     // Wait for socket to become ready.
-    if (socket_ops::poll_read(s, 0, ec) < 0)
+    if (socket_ops::poll_read(s, ec) < 0)
       return 0;
   }
 }
 
 #if defined(BOOST_ASIO_HAS_IOCP)
 
 void complete_iocp_recvfrom(
     const weak_cancel_token_type& cancel_token,
     boost::system::error_code& ec)
 {
   // Map non-portable errors to their portable counterparts.
   if (ec.value() == ERROR_NETNAME_DELETED)
   {
     if (cancel_token.expired())
       ec = boost::asio::error::operation_aborted;
     else
       ec = boost::asio::error::connection_reset;
   }
   else if (ec.value() == ERROR_PORT_UNREACHABLE)
   {
     ec = boost::asio::error::connection_refused;
   }
 }
 
 #else // defined(BOOST_ASIO_HAS_IOCP)
 
 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)
 {
   for (;;)
   {
     // Read some data.
     int 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.
     if (ec == boost::asio::error::would_block
         || ec == boost::asio::error::try_again)
       return false;
 
     // Operation is complete.
     if (bytes >= 0)
     {
       ec = boost::system::error_code();
       bytes_transferred = bytes;
     }
     else
       bytes_transferred = 0;
 
     return true;
   }
 }
 
 #endif // defined(BOOST_ASIO_HAS_IOCP)
 
-int 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__)
-  out_flags = 0;
-  return socket_ops::recv(s, bufs, count, in_flags, ec);
-#else // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
-  msghdr msg = msghdr();
-  msg.msg_iov = bufs;
-  msg.msg_iovlen = count;
-  int 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__)
-}
-
-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 (s == invalid_socket)
-  {
-    ec = boost::asio::error::bad_descriptor;
-    return 0;
-  }
-
-  // Read some data.
-  for (;;)
-  {
-    // Try to complete the operation without blocking.
-    int bytes = socket_ops::recvmsg(s, bufs, count, in_flags, out_flags, ec);
-
-    // Check if operation succeeded.
-    if (bytes >= 0)
-      return bytes;
-
-    // Operation failed.
-    if ((state & user_set_non_blocking)
-        || (ec != boost::asio::error::would_block
-          && ec != boost::asio::error::try_again))
-      return 0;
-
-    // Wait for socket to become ready.
-    if (socket_ops::poll_read(s, 0, ec) < 0)
-      return 0;
-  }
-}
-
-#if defined(BOOST_ASIO_HAS_IOCP)
-
-void complete_iocp_recvmsg(
-    const weak_cancel_token_type& cancel_token,
-    boost::system::error_code& ec)
-{
-  // Map non-portable errors to their portable counterparts.
-  if (ec.value() == ERROR_NETNAME_DELETED)
-  {
-    if (cancel_token.expired())
-      ec = boost::asio::error::operation_aborted;
-    else
-      ec = boost::asio::error::connection_reset;
-  }
-  else if (ec.value() == ERROR_PORT_UNREACHABLE)
-  {
-    ec = boost::asio::error::connection_refused;
-  }
-}
-
-#else // defined(BOOST_ASIO_HAS_IOCP)
-
-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);
-
-    // Retry operation if interrupted by signal.
-    if (ec == boost::asio::error::interrupted)
-      continue;
-
-    // Check if we need to run the operation again.
-    if (ec == boost::asio::error::would_block
-        || ec == boost::asio::error::try_again)
-      return false;
-
-    // Operation is complete.
-    if (bytes >= 0)
-    {
-      ec = boost::system::error_code();
-      bytes_transferred = bytes;
-    }
-    else
-      bytes_transferred = 0;
-
-    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)
 {
   clear_last_error();
 #if defined(BOOST_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);
   if (ec.value() == ERROR_NETNAME_DELETED)
     ec = boost::asio::error::connection_reset;
   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__)
   msghdr msg = msghdr();
   msg.msg_iov = const_cast<buf*>(bufs);
   msg.msg_iovlen = count;
 #if defined(__linux__)
   flags |= MSG_NOSIGNAL;
 #endif // defined(__linux__)
   int result = error_wrapper(::sendmsg(s, &msg, flags), ec);
   if (result >= 0)
     ec = boost::system::error_code();
   return result;
 #endif // defined(BOOST_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)
   {
     ec = boost::asio::error::bad_descriptor;
     return 0;
   }
 
   // A request to write 0 bytes to a stream is a no-op.
   if (all_empty && (state & stream_oriented))
   {
     ec = boost::system::error_code();
     return 0;
   }
 
   // Read some data.
   for (;;)
   {
     // Try to complete the operation without blocking.
     int bytes = socket_ops::send(s, bufs, count, flags, ec);
 
     // Check if operation succeeded.
     if (bytes >= 0)
       return bytes;
 
     // Operation failed.
     if ((state & user_set_non_blocking)
         || (ec != boost::asio::error::would_block
           && ec != boost::asio::error::try_again))
       return 0;
 
     // Wait for socket to become ready.
-    if (socket_ops::poll_write(s, 0, ec) < 0)
+    if (socket_ops::poll_write(s, ec) < 0)
       return 0;
   }
 }
 
 #if defined(BOOST_ASIO_HAS_IOCP)
 
 void complete_iocp_send(
     const weak_cancel_token_type& cancel_token,
     boost::system::error_code& ec)
 {
   // Map non-portable errors to their portable counterparts.
   if (ec.value() == ERROR_NETNAME_DELETED)
   {
     if (cancel_token.expired())
       ec = boost::asio::error::operation_aborted;
     else
       ec = boost::asio::error::connection_reset;
   }
   else if (ec.value() == ERROR_PORT_UNREACHABLE)
   {
     ec = boost::asio::error::connection_refused;
   }
 }
 
 #else // defined(BOOST_ASIO_HAS_IOCP)
 
 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);
 
@@ -1206,71 +1020,71 @@ int sendto(socket_type s, const buf* bufs, size_t count, int flags,
 #endif // defined(__linux__)
   int result = error_wrapper(::sendmsg(s, &msg, flags), ec);
   if (result >= 0)
     ec = boost::system::error_code();
   return result;
 #endif // defined(BOOST_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)
 {
   if (s == invalid_socket)
   {
     ec = boost::asio::error::bad_descriptor;
     return 0;
   }
 
   // Write some data.
   for (;;)
   {
     // Try to complete the operation without blocking.
     int bytes = socket_ops::sendto(s, bufs, count, flags, addr, addrlen, ec);
 
     // Check if operation succeeded.
     if (bytes >= 0)
       return bytes;
 
     // Operation failed.
     if ((state & user_set_non_blocking)
         || (ec != boost::asio::error::would_block
           && ec != boost::asio::error::try_again))
       return 0;
 
     // Wait for socket to become ready.
-    if (socket_ops::poll_write(s, 0, ec) < 0)
+    if (socket_ops::poll_write(s, ec) < 0)
       return 0;
   }
 }
 
 #if !defined(BOOST_ASIO_HAS_IOCP)
 
 bool non_blocking_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, size_t& bytes_transferred)
 {
   for (;;)
   {
     // Write some data.
     int 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.
     if (ec == boost::asio::error::would_block
         || ec == boost::asio::error::try_again)
       return false;
 
     // Operation is complete.
     if (bytes >= 0)
     {
       ec = boost::system::error_code();
       bytes_transferred = bytes;
     }
     else
       bytes_transferred = 0;
 
     return true;
@@ -1656,150 +1470,140 @@ int select(int nfds, fd_set* readfds, fd_set* writefds,
   {
     DWORD milliseconds = timeout->tv_sec * 1000 + timeout->tv_usec / 1000;
     if (milliseconds == 0)
       milliseconds = 1; // Force context switch.
     ::Sleep(milliseconds);
     ec = boost::system::error_code();
     return 0;
   }
 
   // The select() call allows timeout values measured in microseconds, but the
   // system clock (as wrapped by boost::posix_time::microsec_clock) typically
   // has a resolution of 10 milliseconds. This can lead to a spinning select
   // 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__)
 
 #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,
         writefds, exceptfds, timeout ? &ts : 0, 0), ec);
 #else
   int result = error_wrapper(::select(nfds, readfds,
         writefds, exceptfds, timeout), ec);
   if (result >= 0)
     ec = boost::system::error_code();
   return result;
 #endif
 }
 
-int poll_read(socket_type s, state_type state, boost::system::error_code& ec)
+int poll_read(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) \
   || 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);
+  int result = error_wrapper(::select(s, &fds, 0, 0, 0), ec);
+  if (result >= 0)
+    ec = boost::system::error_code();
+  return result;
 #else // defined(BOOST_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);
+  int result = error_wrapper(::poll(&fds, 1, -1), ec);
+  if (result >= 0)
+    ec = boost::system::error_code();
+  return result;
 #endif // defined(BOOST_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)
-    ec = boost::system::error_code();
-  return result;
 }
 
-int poll_write(socket_type s, state_type state, boost::system::error_code& ec)
+int poll_write(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) \
   || 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);
+  int result = error_wrapper(::select(s, 0, &fds, 0, 0), ec);
+  if (result >= 0)
+    ec = boost::system::error_code();
+  return result;
 #else // defined(BOOST_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);
+  int result = error_wrapper(::poll(&fds, 1, -1), ec);
+  if (result >= 0)
+    ec = boost::system::error_code();
+  return result;
 #endif // defined(BOOST_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)
-    ec = boost::system::error_code();
-  return result;
 }
 
 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) \
   || 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);
   if (result >= 0)
     ec = boost::system::error_code();
   return result;
 #else // defined(BOOST_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();
@@ -1844,72 +1648,71 @@ const char* inet_ntop(int af, const void* src, char* dest, size_t length,
     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)
   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(
         &address.base, address_length, 0, dest, &string_length), ec);
 #endif
 
   // Windows may set error code on success.
   if (result != socket_error_retval)
     ec = boost::system::error_code();
 
   // 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);
   if (result == 0 && !ec)
     ec = boost::asio::error::invalid_argument;
   if (result != 0 && af == 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));
+    bool is_link_local = IN6_IS_ADDR_LINKLOCAL(ipv6_address);
     if (!is_link_local || if_indextoname(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__)
 }
 
 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__)
   using namespace std; // For memcpy and strcmp.
 
   if (af != AF_INET && af != AF_INET6)
   {
     ec = boost::asio::error::address_family_not_supported;
     return -1;
   }
 
   union
   {
     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)
   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);
@@ -1929,72 +1732,71 @@ int inet_pton(int af, const char* src, void* dest,
     {
       static_cast<in4_addr_type*>(dest)->s_addr = INADDR_NONE;
       ec = boost::system::error_code();
     }
   }
   else // AF_INET6
   {
     if (result != socket_error_retval)
     {
       memcpy(dest, &address.v6.sin6_addr, sizeof(in6_addr_type));
       if (scope_id)
         *scope_id = address.v6.sin6_scope_id;
       ec = boost::system::error_code();
     }
   }
 
   // Windows may not set an error code on failure.
   if (result == socket_error_retval && !ec)
     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__)
   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)
   {
     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));
+      bool is_link_local = IN6_IS_ADDR_LINKLOCAL(ipv6_address);
       if (is_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__)
 }
 
 int gethostname(char* name, int namelen, boost::system::error_code& ec)
 {
   clear_last_error();
   int result = error_wrapper(::gethostname(name, namelen), ec);
 #if defined(BOOST_WINDOWS)
   if (result == 0)
     ec = boost::system::error_code();
 #endif
   return result;
 }
 
 #if defined(BOOST_WINDOWS) || defined(__CYGWIN__) \
   || defined(__MACH__) && defined(__APPLE__)
 
 // The following functions are only needed for emulation of getaddrinfo and
 // getnameinfo.
 
 inline boost::system::error_code translate_netdb_error(int error)
 {
   switch (error)
   {
   case 0:
     return boost::system::error_code();
   case HOST_NOT_FOUND:
     return boost::asio::error::host_not_found;
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..3b64771 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,78 +1,73 @@
 //
 // detail/impl/socket_select_interrupter.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_IMPL_SOCKET_SELECT_INTERRUPTER_IPP
 #define BOOST_ASIO_DETAIL_IMPL_SOCKET_SELECT_INTERRUPTER_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_WINDOWS) \
   || defined(__CYGWIN__) \
   || defined(__SYMBIAN32__)
 
 #include <cstdlib>
 #include <boost/asio/detail/socket_holder.hpp>
 #include <boost/asio/detail/socket_ops.hpp>
 #include <boost/asio/detail/socket_select_interrupter.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 {
 
 socket_select_interrupter::socket_select_interrupter()
 {
-  open_descriptors();
-}
-
-void socket_select_interrupter::open_descriptors()
-{
   boost::system::error_code ec;
   socket_holder acceptor(socket_ops::socket(
         AF_INET, SOCK_STREAM, IPPROTO_TCP, ec));
   if (acceptor.get() == invalid_socket)
     boost::asio::detail::throw_error(ec, "socket_select_interrupter");
 
   int opt = 1;
   socket_ops::state_type acceptor_state = 0;
   socket_ops::setsockopt(acceptor.get(), acceptor_state,
       SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt), ec);
 
   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_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");
 
   if (socket_ops::listen(acceptor.get(),
         SOMAXCONN, ec) == socket_error_retval)
     boost::asio::detail::throw_error(ec, "socket_select_interrupter");
 
@@ -83,91 +78,76 @@ void socket_select_interrupter::open_descriptors()
 
   if (socket_ops::connect(client.get(), (const socket_addr_type*)&addr,
         addr_len, ec) == socket_error_retval)
     boost::asio::detail::throw_error(ec, "socket_select_interrupter");
 
   socket_holder server(socket_ops::accept(acceptor.get(), 0, 0, ec));
   if (server.get() == invalid_socket)
     boost::asio::detail::throw_error(ec, "socket_select_interrupter");
   
   ioctl_arg_type non_blocking = 1;
   socket_ops::state_type client_state = 0;
   if (socket_ops::ioctl(client.get(), client_state,
         FIONBIO, &non_blocking, ec))
     boost::asio::detail::throw_error(ec, "socket_select_interrupter");
 
   opt = 1;
   socket_ops::setsockopt(client.get(), client_state,
       IPPROTO_TCP, TCP_NODELAY, &opt, sizeof(opt), ec);
 
   non_blocking = 1;
   socket_ops::state_type server_state = 0;
   if (socket_ops::ioctl(server.get(), server_state,
         FIONBIO, &non_blocking, ec))
     boost::asio::detail::throw_error(ec, "socket_select_interrupter");
 
   opt = 1;
   socket_ops::setsockopt(server.get(), server_state,
       IPPROTO_TCP, TCP_NODELAY, &opt, sizeof(opt), ec);
 
   read_descriptor_ = server.release();
   write_descriptor_ = client.release();
 }
 
 socket_select_interrupter::~socket_select_interrupter()
 {
-  close_descriptors();
-}
-
-void socket_select_interrupter::close_descriptors()
-{
   boost::system::error_code ec;
   socket_ops::state_type state = socket_ops::internal_non_blocking;
   if (read_descriptor_ != invalid_socket)
     socket_ops::close(read_descriptor_, state, true, ec);
   if (write_descriptor_ != invalid_socket)
     socket_ops::close(write_descriptor_, state, true, ec);
 }
 
-void socket_select_interrupter::recreate()
-{
-  close_descriptors();
-
-  write_descriptor_ = invalid_socket;
-  read_descriptor_ = invalid_socket;
-
-  open_descriptors();
-}
-
 void socket_select_interrupter::interrupt()
 {
   char byte = 0;
   socket_ops::buf b;
   socket_ops::init_buf(b, &byte, 1);
   boost::system::error_code ec;
   socket_ops::send(write_descriptor_, &b, 1, 0, ec);
 }
 
 bool socket_select_interrupter::reset()
 {
   char data[1024];
   socket_ops::buf b;
   socket_ops::init_buf(b, data, sizeof(data));
   boost::system::error_code ec;
   int bytes_read = socket_ops::recv(read_descriptor_, &b, 1, 0, ec);
   bool was_interrupted = (bytes_read > 0);
   while (bytes_read == sizeof(data))
     bytes_read = socket_ops::recv(read_descriptor_, &b, 1, 0, ec);
   return was_interrupted;
 }
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // defined(BOOST_WINDOWS)
        // || defined(__CYGWIN__)
        // || defined(__SYMBIAN32__)
 
 #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..5cb320d 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/strand_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/strand_service.hpp
@@ -1,116 +1,142 @@
 //
 // detail/impl/strand_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_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/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>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 inline strand_service::strand_impl::strand_impl()
   : operation(&strand_service::do_complete),
-    locked_(false)
+    count_(0)
 {
 }
 
 struct strand_service::on_dispatch_exit
 {
   io_service_impl* io_service_;
   strand_impl* impl_;
 
   ~on_dispatch_exit()
   {
     impl_->mutex_.lock();
-    impl_->ready_queue_.push(impl_->waiting_queue_);
-    bool more_handlers = impl_->locked_ = !impl_->ready_queue_.empty();
+    bool more_handlers = (--impl_->count_ > 0);
     impl_->mutex_.unlock();
 
     if (more_handlers)
       io_service_->post_immediate_completion(impl_);
   }
 };
 
+inline void strand_service::destroy(strand_service::implementation_type& impl)
+{
+  impl = 0;
+}
+
 template <typename Handler>
 void strand_service::dispatch(strand_service::implementation_type& impl,
     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::detail::fenced_block b;
     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),
     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"));
+  // If we are running inside the io_service, and no other handler is queued
+  // or running, then the handler can run immediately.
+  bool can_dispatch = call_stack<io_service_impl>::contains(&io_service_);
+  impl->mutex_.lock();
+  bool first = (++impl->count_ == 1);
+  if (can_dispatch && first)
+  {
+    // Immediate invocation is allowed.
+    impl->mutex_.unlock();
 
-  bool dispatch_immediately = do_dispatch(impl, p.p);
-  operation* o = p.p;
-  p.v = p.p = 0;
+    // Memory must be releaesed before any upcall is made.
+    p.reset();
 
-  if (dispatch_immediately)
-  {
     // Indicate that this strand is executing on the current thread.
     call_stack<strand_impl>::context ctx(impl);
 
     // Ensure the next handler, if any, is scheduled on block exit.
     on_dispatch_exit on_exit = { &io_service_, impl };
     (void)on_exit;
 
-    completion_handler<Handler>::do_complete(
-        &io_service_, o, boost::system::error_code(), 0);
+    boost::asio::detail::fenced_block b;
+    boost_asio_handler_invoke_helpers::invoke(handler, handler);
+    return;
   }
+
+  // Immediate invocation is not allowed, so enqueue for later.
+  impl->queue_.push(p.p);
+  impl->mutex_.unlock();
+  p.v = p.p = 0;
+
+  // The first handler to be enqueued is responsible for scheduling the
+  // strand.
+  if (first)
+    io_service_.post_immediate_completion(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)
 {
   // Allocate and construct an operation to wrap the handler.
   typedef completion_handler<Handler> op;
   typename op::ptr p = { boost::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);
+  // Add the handler to the queue.
+  impl->mutex_.lock();
+  bool first = (++impl->count_ == 1);
+  impl->queue_.push(p.p);
+  impl->mutex_.unlock();
   p.v = p.p = 0;
+
+  // The first handler to be enqueue is responsible for scheduling the strand.
+  if (first)
+    io_service_.post_immediate_completion(impl);
 }
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // BOOST_ASIO_DETAIL_IMPL_STRAND_SERVICE_HPP
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..6a42146 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/strand_service.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/strand_service.ipp
@@ -1,171 +1,108 @@
 //
 // detail/impl/strand_service.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_IMPL_STRAND_SERVICE_IPP
 #define BOOST_ASIO_DETAIL_IMPL_STRAND_SERVICE_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/detail/strand_service.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 struct strand_service::on_do_complete_exit
 {
   io_service_impl* owner_;
   strand_impl* impl_;
 
   ~on_do_complete_exit()
   {
     impl_->mutex_.lock();
-    impl_->ready_queue_.push(impl_->waiting_queue_);
-    bool more_handlers = impl_->locked_ = !impl_->ready_queue_.empty();
+    bool more_handlers = (--impl_->count_ > 0);
     impl_->mutex_.unlock();
 
     if (more_handlers)
-      owner_->post_private_immediate_completion(impl_);
+      owner_->post_immediate_completion(impl_);
   }
 };
 
 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)),
     mutex_(),
     salt_(0)
 {
 }
 
 void strand_service::shutdown_service()
 {
   op_queue<operation> ops;
 
   boost::asio::detail::mutex::scoped_lock lock(mutex_);
 
   for (std::size_t i = 0; i < num_implementations; ++i)
-  {
     if (strand_impl* impl = implementations_[i].get())
-    {
-      ops.push(impl->waiting_queue_);
-      ops.push(impl->ready_queue_);
-    }
-  }
+      ops.push(impl->queue_);
 }
 
 void strand_service::construct(strand_service::implementation_type& impl)
 {
-  boost::asio::detail::mutex::scoped_lock lock(mutex_);
-
   std::size_t salt = salt_++;
-#if defined(BOOST_ASIO_ENABLE_SEQUENTIAL_STRAND_ALLOCATION)
-  std::size_t index = salt;
-#else // defined(BOOST_ASIO_ENABLE_SEQUENTIAL_STRAND_ALLOCATION)
   std::size_t index = reinterpret_cast<std::size_t>(&impl);
   index += (reinterpret_cast<std::size_t>(&impl) >> 3);
   index ^= salt + 0x9e3779b9 + (index << 6) + (index >> 2);
-#endif // defined(BOOST_ASIO_ENABLE_SEQUENTIAL_STRAND_ALLOCATION)
   index = index % num_implementations;
 
-  if (!implementations_[index].get())
+  boost::asio::detail::mutex::scoped_lock lock(mutex_);
+
+  if (!implementations_[index])
     implementations_[index].reset(new strand_impl);
   impl = implementations_[index].get();
 }
 
-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();
-  if (can_dispatch && !impl->locked_)
-  {
-    // Immediate invocation is allowed.
-    impl->locked_ = true;
-    impl->mutex_.unlock();
-    return true;
-  }
-
-  if (impl->locked_)
-  {
-    // Some other handler already holds the strand lock. Enqueue for later.
-    impl->waiting_queue_.push(op);
-    impl->mutex_.unlock();
-  }
-  else
-  {
-    // 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);
-  }
-
-  return false;
-}
-
-void strand_service::do_post(implementation_type& impl, operation* op)
-{
-  impl->mutex_.lock();
-  if (impl->locked_)
-  {
-    // Some other handler already holds the strand lock. Enqueue for later.
-    impl->waiting_queue_.push(op);
-    impl->mutex_.unlock();
-  }
-  else
-  {
-    // 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);
-  }
-}
-
 void strand_service::do_complete(io_service_impl* owner, operation* base,
-    const boost::system::error_code& ec, std::size_t /*bytes_transferred*/)
+    boost::system::error_code /*ec*/, std::size_t /*bytes_transferred*/)
 {
   if (owner)
   {
     strand_impl* impl = static_cast<strand_impl*>(base);
 
+    // Get the next handler to be executed.
+    impl->mutex_.lock();
+    operation* o = impl->queue_.front();
+    impl->queue_.pop();
+    impl->mutex_.unlock();
+
     // Indicate that this strand is executing on the current thread.
     call_stack<strand_impl>::context ctx(impl);
 
     // Ensure the next handler, if any, is scheduled on block exit.
     on_do_complete_exit on_exit = { owner, impl };
     (void)on_exit;
 
-    // Run all ready handlers. No lock is required since the ready queue is
-    // accessed only within the strand.
-    while (operation* o = impl->ready_queue_.front())
-    {
-      impl->ready_queue_.pop();
-      o->complete(*owner, ec, 0);
-    }
+    o->complete(*owner);
   }
 }
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // BOOST_ASIO_DETAIL_IMPL_STRAND_SERVICE_IPP
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..a002189 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,75 +1,62 @@
 //
 // detail/impl/task_io_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_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/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>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 template <typename Handler>
 void task_io_service::dispatch(Handler handler)
 {
-  if (thread_call_stack::contains(this))
+  if (call_stack<task_io_service>::contains(this))
   {
-    fenced_block b(fenced_block::full);
+    boost::asio::detail::fenced_block b;
     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),
-      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);
-    p.v = p.p = 0;
-  }
+    post(handler);
 }
 
 template <typename Handler>
 void task_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),
     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);
   p.v = p.p = 0;
 }
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // BOOST_ASIO_DETAIL_IMPL_TASK_IO_SERVICE_HPP
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..babfa7b 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,544 +1,356 @@
 //
 // detail/impl/task_io_service.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_IMPL_TASK_IO_SERVICE_IPP
 #define BOOST_ASIO_DETAIL_IMPL_TASK_IO_SERVICE_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_HAS_IOCP)
 
 #include <boost/limits.hpp>
+#include <boost/asio/detail/call_stack.hpp>
 #include <boost/asio/detail/event.hpp>
 #include <boost/asio/detail/reactor.hpp>
 #include <boost/asio/detail/task_io_service.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)
-    {
-      boost::asio::detail::increment(
-          task_io_service_->outstanding_work_,
-          this_thread_->private_outstanding_work);
-    }
-    this_thread_->private_outstanding_work = 0;
-
     // Enqueue the completed operations and reinsert the task at the end of
     // the operation queue.
     lock_->lock();
     task_io_service_->task_interrupted_ = true;
-    task_io_service_->op_queue_.push(this_thread_->private_op_queue);
+    task_io_service_->op_queue_.push(*ops_);
     task_io_service_->op_queue_.push(&task_io_service_->task_operation_);
   }
 
   task_io_service* task_io_service_;
   mutex::scoped_lock* lock_;
-  thread_info* this_thread_;
+  op_queue<operation>* ops_;
 };
 
-struct task_io_service::work_cleanup
+struct task_io_service::work_finished_on_block_exit
 {
-  ~work_cleanup()
+  ~work_finished_on_block_exit()
   {
-    if (this_thread_->private_outstanding_work > 1)
-    {
-      boost::asio::detail::increment(
-          task_io_service_->outstanding_work_,
-          this_thread_->private_outstanding_work - 1);
-    }
-    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 (!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)
+    task_io_service_->work_finished();
   }
 
   task_io_service* task_io_service_;
-  mutex::scoped_lock* lock_;
-  thread_info* this_thread_;
 };
 
-task_io_service::task_io_service(
-    boost::asio::io_service& io_service, std::size_t concurrency_hint)
+struct task_io_service::idle_thread_info
+{
+  event wakeup_event;
+  idle_thread_info* next;
+};
+
+task_io_service::task_io_service(boost::asio::io_service& io_service)
   : boost::asio::detail::service_base<task_io_service>(io_service),
-    one_thread_(concurrency_hint == 1),
     mutex_(),
     task_(0),
     task_interrupted_(true),
     outstanding_work_(0),
     stopped_(false),
     shutdown_(false),
     first_idle_thread_(0)
 {
-  BOOST_ASIO_HANDLER_TRACKING_INIT;
+}
+
+void task_io_service::init(std::size_t /*concurrency_hint*/)
+{
 }
 
 void task_io_service::shutdown_service()
 {
   mutex::scoped_lock lock(mutex_);
   shutdown_ = true;
   lock.unlock();
 
   // Destroy handler objects.
   while (!op_queue_.empty())
   {
     operation* o = op_queue_.front();
     op_queue_.pop();
     if (o != &task_operation_)
       o->destroy();
   }
 
   // Reset to initial state.
   task_ = 0;
 }
 
 void task_io_service::init_task()
 {
   mutex::scoped_lock lock(mutex_);
   if (!shutdown_ && !task_)
   {
     task_ = &use_service<reactor>(this->get_io_service());
     op_queue_.push(&task_operation_);
     wake_one_thread_and_unlock(lock);
   }
 }
 
 std::size_t task_io_service::run(boost::system::error_code& ec)
 {
   ec = boost::system::error_code();
   if (outstanding_work_ == 0)
   {
     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);
+  call_stack<task_io_service>::context ctx(this);
+
+  idle_thread_info this_idle_thread;
+  this_idle_thread.next = 0;
 
   mutex::scoped_lock lock(mutex_);
 
   std::size_t n = 0;
-  for (; do_run_one(lock, this_thread, ec); lock.lock())
+  for (; do_one(lock, &this_idle_thread); lock.lock())
     if (n != (std::numeric_limits<std::size_t>::max)())
       ++n;
   return n;
 }
 
 std::size_t task_io_service::run_one(boost::system::error_code& ec)
 {
   ec = boost::system::error_code();
   if (outstanding_work_ == 0)
   {
     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);
+  call_stack<task_io_service>::context ctx(this);
+
+  idle_thread_info this_idle_thread;
+  this_idle_thread.next = 0;
 
   mutex::scoped_lock lock(mutex_);
 
-  return do_run_one(lock, this_thread, ec);
+  return do_one(lock, &this_idle_thread);
 }
 
 std::size_t task_io_service::poll(boost::system::error_code& ec)
 {
-  ec = boost::system::error_code();
   if (outstanding_work_ == 0)
   {
     stop();
+    ec = boost::system::error_code();
     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);
+  call_stack<task_io_service>::context ctx(this);
 
   mutex::scoped_lock lock(mutex_);
 
-#if defined(BOOST_HAS_THREADS) && !defined(BOOST_ASIO_DISABLE_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)
-
   std::size_t n = 0;
-  for (; do_poll_one(lock, this_thread, ec); lock.lock())
+  for (; do_one(lock, 0); lock.lock())
     if (n != (std::numeric_limits<std::size_t>::max)())
       ++n;
   return n;
 }
 
 std::size_t task_io_service::poll_one(boost::system::error_code& ec)
 {
   ec = boost::system::error_code();
   if (outstanding_work_ == 0)
   {
     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);
+  call_stack<task_io_service>::context ctx(this);
 
   mutex::scoped_lock lock(mutex_);
 
-#if defined(BOOST_HAS_THREADS) && !defined(BOOST_ASIO_DISABLE_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)
-
-  return do_poll_one(lock, this_thread, ec);
+  return do_one(lock, 0);
 }
 
 void task_io_service::stop()
 {
   mutex::scoped_lock lock(mutex_);
   stop_all_threads(lock);
 }
 
-bool task_io_service::stopped() const
-{
-  mutex::scoped_lock lock(mutex_);
-  return stopped_;
-}
-
 void task_io_service::reset()
 {
   mutex::scoped_lock lock(mutex_);
   stopped_ = false;
 }
 
 void task_io_service::post_immediate_completion(task_io_service::operation* op)
 {
-#if defined(BOOST_HAS_THREADS) && !defined(BOOST_ASIO_DISABLE_THREADS)
-  if (one_thread_)
-  {
-    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)
-
   work_started();
-  mutex::scoped_lock lock(mutex_);
-  op_queue_.push(op);
-  wake_one_thread_and_unlock(lock);
+  post_deferred_completion(op);
 }
 
 void task_io_service::post_deferred_completion(task_io_service::operation* op)
 {
-#if defined(BOOST_HAS_THREADS) && !defined(BOOST_ASIO_DISABLE_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)
-
   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 (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)
-
     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(
-    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(
-    op_queue<task_io_service::operation>& ops)
-{
-  op_queue<task_io_service::operation> ops2;
-  ops2.push(ops);
-}
-
-std::size_t task_io_service::do_run_one(mutex::scoped_lock& lock,
-    task_io_service::thread_info& this_thread,
-    const boost::system::error_code& ec)
+std::size_t task_io_service::do_one(mutex::scoped_lock& lock,
+    task_io_service::idle_thread_info* this_idle_thread)
 {
+  bool polling = !this_idle_thread;
+  bool task_has_run = false;
   while (!stopped_)
   {
     if (!op_queue_.empty())
     {
       // Prepare to execute first handler from queue.
       operation* o = op_queue_.front();
       op_queue_.pop();
       bool more_handlers = (!op_queue_.empty());
 
       if (o == &task_operation_)
       {
-        task_interrupted_ = more_handlers;
+        task_interrupted_ = more_handlers || polling;
 
-        if (more_handlers && !one_thread_)
+        // If the task has already run and we're polling then we're done.
+        if (task_has_run && polling)
         {
-          if (!wake_one_idle_thread_and_unlock(lock))
-            lock.unlock();
+          task_interrupted_ = true;
+          op_queue_.push(&task_operation_);
+          return 0;
         }
-        else
+        task_has_run = true;
+
+        if (!more_handlers || !wake_one_idle_thread_and_unlock(lock))
           lock.unlock();
 
-        task_cleanup on_exit = { this, &lock, &this_thread };
-        (void)on_exit;
+        op_queue<operation> completed_ops;
+        task_cleanup c = { this, &lock, &completed_ops };
+        (void)c;
 
         // Run the task. May throw an exception. Only block if the operation
         // queue is empty and we're not polling, otherwise we want to return
         // as soon as possible.
-        task_->run(!more_handlers, this_thread.private_op_queue);
+        task_->run(!more_handlers && !polling, completed_ops);
       }
       else
       {
-        std::size_t task_result = o->task_result_;
-
-        if (more_handlers && !one_thread_)
+        if (more_handlers)
           wake_one_thread_and_unlock(lock);
         else
           lock.unlock();
 
         // Ensure the count of outstanding work is decremented on block exit.
-        work_cleanup on_exit = { this, &lock, &this_thread };
+        work_finished_on_block_exit on_exit = { this };
         (void)on_exit;
 
-        // Complete the operation. May throw an exception. Deletes the object.
-        o->complete(*this, ec, task_result);
+        // Complete the operation. May throw an exception.
+        o->complete(*this); // deletes the operation object
 
         return 1;
       }
     }
-    else
+    else if (this_idle_thread)
     {
       // 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);
+      this_idle_thread->next = first_idle_thread_;
+      first_idle_thread_ = this_idle_thread;
+      this_idle_thread->wakeup_event.clear(lock);
+      this_idle_thread->wakeup_event.wait(lock);
     }
-  }
-
-  return 0;
-}
-
-std::size_t task_io_service::do_poll_one(mutex::scoped_lock& lock,
-    task_io_service::thread_info& this_thread,
-    const boost::system::error_code& ec)
-{
-  if (stopped_)
-    return 0;
-
-  operation* o = op_queue_.front();
-  if (o == &task_operation_)
-  {
-    op_queue_.pop();
-    lock.unlock();
-
+    else
     {
-      task_cleanup c = { this, &lock, &this_thread };
-      (void)c;
-
-      // Run the task. May throw an exception. Only block if the operation
-      // queue is empty and we're not polling, otherwise we want to return
-      // as soon as possible.
-      task_->run(false, this_thread.private_op_queue);
-    }
-
-    o = op_queue_.front();
-    if (o == &task_operation_)
       return 0;
+    }
   }
 
-  if (o == 0)
-    return 0;
-
-  op_queue_.pop();
-  bool more_handlers = (!op_queue_.empty());
-
-  std::size_t task_result = o->task_result_;
-
-  if (more_handlers && !one_thread_)
-    wake_one_thread_and_unlock(lock);
-  else
-    lock.unlock();
-
-  // Ensure the count of outstanding work is decremented on block exit.
-  work_cleanup on_exit = { this, &lock, &this_thread };
-  (void)on_exit;
-
-  // Complete the operation. May throw an exception. Deletes the object.
-  o->complete(*this, ec, task_result);
-
-  return 1;
+  return 0;
 }
 
 void task_io_service::stop_all_threads(
     mutex::scoped_lock& lock)
 {
   stopped_ = true;
 
   while (first_idle_thread_)
   {
-    thread_info* idle_thread = first_idle_thread_;
+    idle_thread_info* idle_thread = first_idle_thread_;
     first_idle_thread_ = idle_thread->next;
     idle_thread->next = 0;
-    idle_thread->wakeup_event->signal(lock);
+    idle_thread->wakeup_event.signal(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_;
+    idle_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);
+    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 (!task_interrupted_ && task_)
     {
       task_interrupted_ = true;
       task_->interrupt();
     }
     lock.unlock();
   }
 }
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // !defined(BOOST_ASIO_HAS_IOCP)
 
 #endif // BOOST_ASIO_DETAIL_IMPL_TASK_IO_SERVICE_IPP
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..5ba6b9c 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/throw_error.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/throw_error.ipp
@@ -1,40 +1,40 @@
 //
 // detail/impl/throw_error.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_IMPL_THROW_ERROR_IPP
 #define BOOST_ASIO_DETAIL_IMPL_THROW_ERROR_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/throw_exception.hpp>
 #include <boost/asio/detail/throw_error.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);
 }
 
 void do_throw_error(const boost::system::error_code& err, const char* location)
 {
   boost::system::system_error e(err, location);
   boost::throw_exception(e);
 }
 
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
deleted file mode 100644
index c72d885..0000000
--- a/3rdParty/Boost/src/boost/asio/detail/impl/timer_queue_ptime.ipp
+++ /dev/null
@@ -1,82 +0,0 @@
-//
-// detail/impl/timer_queue_ptime.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// 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_IMPL_TIMER_QUEUE_PTIME_IPP
-#define BOOST_ASIO_DETAIL_IMPL_TIMER_QUEUE_PTIME_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/timer_queue_ptime.hpp>
-
-#include <boost/asio/detail/push_options.hpp>
-
-namespace boost {
-namespace asio {
-namespace detail {
-
-timer_queue<time_traits<boost::posix_time::ptime> >::timer_queue()
-{
-}
-
-timer_queue<time_traits<boost::posix_time::ptime> >::~timer_queue()
-{
-}
-
-bool timer_queue<time_traits<boost::posix_time::ptime> >::enqueue_timer(
-    const time_type& time, per_timer_data& timer, wait_op* op)
-{
-  return impl_.enqueue_timer(time, timer, op);
-}
-
-bool timer_queue<time_traits<boost::posix_time::ptime> >::empty() const
-{
-  return impl_.empty();
-}
-
-long timer_queue<time_traits<boost::posix_time::ptime> >::wait_duration_msec(
-    long max_duration) const
-{
-  return impl_.wait_duration_msec(max_duration);
-}
-
-long timer_queue<time_traits<boost::posix_time::ptime> >::wait_duration_usec(
-    long max_duration) const
-{
-  return impl_.wait_duration_usec(max_duration);
-}
-
-void timer_queue<time_traits<boost::posix_time::ptime> >::get_ready_timers(
-    op_queue<operation>& ops)
-{
-  impl_.get_ready_timers(ops);
-}
-
-void timer_queue<time_traits<boost::posix_time::ptime> >::get_all_timers(
-    op_queue<operation>& ops)
-{
-  impl_.get_all_timers(ops);
-}
-
-std::size_t timer_queue<time_traits<boost::posix_time::ptime> >::cancel_timer(
-    per_timer_data& timer, op_queue<operation>& ops, std::size_t max_cancelled)
-{
-  return impl_.cancel_timer(timer, ops, max_cancelled);
-}
-
-} // namespace detail
-} // namespace asio
-} // namespace boost
-
-#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..d1027e6 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,40 +1,40 @@
 //
 // detail/impl/timer_queue_set.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_IMPL_TIMER_QUEUE_SET_IPP
 #define BOOST_ASIO_DETAIL_IMPL_TIMER_QUEUE_SET_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/timer_queue_set.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 timer_queue_set::timer_queue_set()
   : first_(0)
 {
 }
 
 void timer_queue_set::insert(timer_queue_base* q)
 {
   q->next_ = first_;
   first_ = q;
 }
 
 void timer_queue_set::erase(timer_queue_base* q)
 {
   if (first_)
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..fe904fb 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/win_event.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/win_event.ipp
@@ -1,40 +1,40 @@
 //
 // detail/win_event.ipp
 // ~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_IMPL_WIN_EVENT_IPP
 #define BOOST_ASIO_DETAIL_IMPL_WIN_EVENT_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_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))
 {
   if (!event_)
   {
     DWORD last_error = ::GetLastError();
     boost::system::error_code ec(last_error,
         boost::asio::error::get_system_category());
     boost::asio::detail::throw_error(ec, "event");
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..eb6643a 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,40 +1,40 @@
 //
 // detail/impl/win_iocp_handle_service.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2011 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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_IMPL_WIN_IOCP_HANDLE_SERVICE_IPP
 #define BOOST_ASIO_DETAIL_IMPL_WIN_IOCP_HANDLE_SERVICE_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_HAS_IOCP)
 
 #include <boost/asio/detail/win_iocp_handle_service.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 class win_iocp_handle_service::overlapped_wrapper
   : public OVERLAPPED
 {
 public:
   explicit overlapped_wrapper(boost::system::error_code& ec)
   {
     Internal = 0;
     InternalHigh = 0;
     Offset = 0;
     OffsetHigh = 0;
@@ -68,206 +68,136 @@ public:
 win_iocp_handle_service::win_iocp_handle_service(
     boost::asio::io_service& io_service)
   : iocp_service_(boost::asio::use_service<win_iocp_io_service>(io_service)),
     mutex_(),
     impl_list_(0)
 {
 }
 
 void win_iocp_handle_service::shutdown_service()
 {
   // Close all implementations, causing all operations to complete.
   boost::asio::detail::mutex::scoped_lock lock(mutex_);
   implementation_type* impl = impl_list_;
   while (impl)
   {
     close_for_destruction(*impl);
     impl = impl->next_;
   }
 }
 
 void win_iocp_handle_service::construct(
     win_iocp_handle_service::implementation_type& impl)
 {
   impl.handle_ = INVALID_HANDLE_VALUE;
   impl.safe_cancellation_thread_id_ = 0;
 
   // 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 win_iocp_handle_service::move_construct(
-    win_iocp_handle_service::implementation_type& impl,
-    win_iocp_handle_service::implementation_type& other_impl)
-{
-  impl.handle_ = other_impl.handle_;
-  other_impl.handle_ = INVALID_HANDLE_VALUE;
-
-  impl.safe_cancellation_thread_id_ = other_impl.safe_cancellation_thread_id_;
-  other_impl.safe_cancellation_thread_id_ = 0;
-
-  // 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 win_iocp_handle_service::move_assign(
-    win_iocp_handle_service::implementation_type& impl,
-    win_iocp_handle_service& other_service,
-    win_iocp_handle_service::implementation_type& other_impl)
-{
-  close_for_destruction(impl);
-
-  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.handle_ = other_impl.handle_;
-  other_impl.handle_ = INVALID_HANDLE_VALUE;
-
-  impl.safe_cancellation_thread_id_ = other_impl.safe_cancellation_thread_id_;
-  other_impl.safe_cancellation_thread_id_ = 0;
-
-  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 win_iocp_handle_service::destroy(
     win_iocp_handle_service::implementation_type& impl)
 {
   close_for_destruction(impl);
   
   // 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 win_iocp_handle_service::assign(
     win_iocp_handle_service::implementation_type& impl,
-    const native_handle_type& handle, boost::system::error_code& ec)
+    const native_type& native_handle, boost::system::error_code& ec)
 {
   if (is_open(impl))
   {
     ec = boost::asio::error::already_open;
     return ec;
   }
 
-  if (iocp_service_.register_handle(handle, ec))
+  if (iocp_service_.register_handle(native_handle, ec))
     return ec;
 
-  impl.handle_ = handle;
+  impl.handle_ = native_handle;
   ec = boost::system::error_code();
   return ec;
 }
 
 boost::system::error_code win_iocp_handle_service::close(
     win_iocp_handle_service::implementation_type& impl,
     boost::system::error_code& ec)
 {
   if (is_open(impl))
   {
-    BOOST_ASIO_HANDLER_OPERATION(("handle", &impl, "close"));
-
     if (!::CloseHandle(impl.handle_))
     {
       DWORD last_error = ::GetLastError();
       ec = boost::system::error_code(last_error,
           boost::asio::error::get_system_category());
-    }
-    else
-    {
-      ec = boost::system::error_code();
+      return ec;
     }
 
     impl.handle_ = INVALID_HANDLE_VALUE;
     impl.safe_cancellation_thread_id_ = 0;
   }
-  else
-  {
-    ec = boost::system::error_code();
-  }
 
+  ec = boost::system::error_code();
   return ec;
 }
 
 boost::system::error_code win_iocp_handle_service::cancel(
     win_iocp_handle_service::implementation_type& impl,
     boost::system::error_code& ec)
 {
   if (!is_open(impl))
   {
     ec = boost::asio::error::bad_descriptor;
-    return ec;
   }
-
-  BOOST_ASIO_HANDLER_OPERATION(("handle", &impl, "cancel"));
-
-  if (FARPROC cancel_io_ex_ptr = ::GetProcAddress(
+  else if (FARPROC cancel_io_ex_ptr = ::GetProcAddress(
         ::GetModuleHandleA("KERNEL32"), "CancelIoEx"))
   {
     // The version of Windows supports cancellation from any thread.
     typedef BOOL (WINAPI* cancel_io_ex_t)(HANDLE, LPOVERLAPPED);
     cancel_io_ex_t cancel_io_ex = (cancel_io_ex_t)cancel_io_ex_ptr;
     if (!cancel_io_ex(impl.handle_, 0))
     {
       DWORD last_error = ::GetLastError();
       if (last_error == ERROR_NOT_FOUND)
       {
         // ERROR_NOT_FOUND means that there were no operations to be
         // cancelled. We swallow this error to match the behaviour on other
         // platforms.
         ec = boost::system::error_code();
       }
       else
       {
         ec = boost::system::error_code(last_error,
             boost::asio::error::get_system_category());
       }
     }
     else
     {
       ec = boost::system::error_code();
     }
   }
   else if (impl.safe_cancellation_thread_id_ == 0)
   {
     // No operations have been started, so there's nothing to cancel.
     ec = boost::system::error_code();
   }
   else if (impl.safe_cancellation_thread_id_ == ::GetCurrentThreadId())
   {
     // Asynchronous operations have been started from the current thread only,
     // so it is safe to try to cancel them using CancelIo.
@@ -475,52 +405,50 @@ void win_iocp_handle_service::start_read_op(
   else
   {
     DWORD bytes_transferred = 0;
     op->Offset = offset & 0xFFFFFFFF;
     op->OffsetHigh = (offset >> 32) & 0xFFFFFFFF;
     BOOL ok = ::ReadFile(impl.handle_,
         boost::asio::buffer_cast<LPVOID>(buffer),
         static_cast<DWORD>(boost::asio::buffer_size(buffer)),
         &bytes_transferred, op);
     DWORD last_error = ::GetLastError();
     if (!ok && last_error != ERROR_IO_PENDING
         && last_error != ERROR_MORE_DATA)
     {
       iocp_service_.on_completion(op, last_error, bytes_transferred);
     }
     else
     {
       iocp_service_.on_pending(op);
     }
   }
 }
 
 void win_iocp_handle_service::update_cancellation_thread_id(
     win_iocp_handle_service::implementation_type& impl)
 {
   if (impl.safe_cancellation_thread_id_ == 0)
     impl.safe_cancellation_thread_id_ = ::GetCurrentThreadId();
   else if (impl.safe_cancellation_thread_id_ != ::GetCurrentThreadId())
     impl.safe_cancellation_thread_id_ = ~DWORD(0);
 }
 
 void win_iocp_handle_service::close_for_destruction(implementation_type& impl)
 {
   if (is_open(impl))
   {
-    BOOST_ASIO_HANDLER_OPERATION(("handle", &impl, "close"));
-
     ::CloseHandle(impl.handle_);
     impl.handle_ = INVALID_HANDLE_VALUE;
     impl.safe_cancellation_thread_id_ = 0;
   }
 }
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // defined(BOOST_ASIO_HAS_IOCP)
 
 #endif // BOOST_ASIO_DETAIL_IMPL_WIN_IOCP_HANDLE_SERVICE_IPP
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..18b9413 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,131 +1,117 @@
 //
 // detail/impl/win_iocp_io_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_IMPL_WIN_IOCP_IO_SERVICE_HPP
 #define BOOST_ASIO_DETAIL_IMPL_WIN_IOCP_IO_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_HAS_IOCP)
 
+#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>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 template <typename Handler>
 void win_iocp_io_service::dispatch(Handler handler)
 {
   if (call_stack<win_iocp_io_service>::contains(this))
   {
-    fenced_block b(fenced_block::full);
+    boost::asio::detail::fenced_block b;
     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),
-      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);
-    p.v = p.p = 0;
-  }
+    post(handler);
 }
 
 template <typename 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),
     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);
   p.v = p.p = 0;
 }
 
 template <typename Time_Traits>
 void win_iocp_io_service::add_timer_queue(
     timer_queue<Time_Traits>& queue)
 {
   do_add_timer_queue(queue);
 }
 
 template <typename Time_Traits>
 void win_iocp_io_service::remove_timer_queue(
     timer_queue<Time_Traits>& queue)
 {
   do_remove_timer_queue(queue);
 }
 
 template <typename Time_Traits>
 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)
+    typename timer_queue<Time_Traits>::per_timer_data& timer, timer_op* op)
 {
   // If the service has been shut down we silently discard the timer.
   if (::InterlockedExchangeAdd(&shutdown_, 0) != 0)
   {
     post_immediate_completion(op);
     return;
   }
 
   mutex::scoped_lock lock(dispatch_mutex_);
 
   bool earliest = queue.enqueue_timer(time, timer, op);
   work_started();
   if (earliest)
     update_timeout();
 }
 
 template <typename Time_Traits>
 std::size_t win_iocp_io_service::cancel_timer(timer_queue<Time_Traits>& queue,
-    typename timer_queue<Time_Traits>::per_timer_data& timer,
-    std::size_t max_cancelled)
+    typename timer_queue<Time_Traits>::per_timer_data& timer)
 {
   // If the service has been shut down we silently ignore the cancellation.
   if (::InterlockedExchangeAdd(&shutdown_, 0) != 0)
     return 0;
 
   mutex::scoped_lock lock(dispatch_mutex_);
   op_queue<win_iocp_operation> ops;
-  std::size_t n = queue.cancel_timer(timer, ops, max_cancelled);
+  std::size_t n = queue.cancel_timer(timer, ops);
   post_deferred_completions(ops);
   return n;
 }
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // defined(BOOST_ASIO_HAS_IOCP)
 
 #endif // BOOST_ASIO_DETAIL_IMPL_WIN_IOCP_IO_SERVICE_HPP
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..9711702 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,309 +1,299 @@
 //
 // detail/impl/win_iocp_io_service.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_IMPL_WIN_IOCP_IO_SERVICE_IPP
 #define BOOST_ASIO_DETAIL_IMPL_WIN_IOCP_IO_SERVICE_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_HAS_IOCP)
 
 #include <boost/limits.hpp>
 #include <boost/asio/error.hpp>
 #include <boost/asio/io_service.hpp>
 #include <boost/asio/detail/handler_alloc_helpers.hpp>
 #include <boost/asio/detail/handler_invoke_helpers.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 {
 namespace asio {
 namespace detail {
 
 struct win_iocp_io_service::work_finished_on_block_exit
 {
   ~work_finished_on_block_exit()
   {
     io_service_->work_finished();
   }
 
   win_iocp_io_service* io_service_;
 };
 
 struct win_iocp_io_service::timer_thread_function
 {
   void operator()()
   {
     while (::InterlockedExchangeAdd(&io_service_->shutdown_, 0) == 0)
     {
       if (::WaitForSingleObject(io_service_->waitable_timer_.handle,
             INFINITE) == WAIT_OBJECT_0)
       {
         ::InterlockedExchange(&io_service_->dispatch_required_, 1);
         ::PostQueuedCompletionStatus(io_service_->iocp_.handle,
             0, wake_for_dispatch, 0);
       }
     }
   }
 
   win_iocp_io_service* io_service_;
 };
 
-win_iocp_io_service::win_iocp_io_service(
-    boost::asio::io_service& io_service, size_t concurrency_hint)
+win_iocp_io_service::win_iocp_io_service(boost::asio::io_service& io_service)
   : boost::asio::detail::service_base<win_iocp_io_service>(io_service),
     iocp_(),
     outstanding_work_(0),
     stopped_(0),
     shutdown_(0),
     dispatch_required_(0)
 {
-  BOOST_ASIO_HANDLER_TRACKING_INIT;
+}
 
+void win_iocp_io_service::init(size_t concurrency_hint)
+{
   iocp_.handle = ::CreateIoCompletionPort(INVALID_HANDLE_VALUE, 0, 0,
       static_cast<DWORD>((std::min<size_t>)(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");
   }
 }
 
 void win_iocp_io_service::shutdown_service()
 {
   ::InterlockedExchange(&shutdown_, 1);
 
-  if (timer_thread_.get())
+  if (timer_thread_)
   {
     LARGE_INTEGER timeout;
     timeout.QuadPart = 1;
     ::SetWaitableTimer(waitable_timer_.handle, &timeout, 1, 0, 0, FALSE);
   }
 
   while (::InterlockedExchangeAdd(&outstanding_work_, 0) > 0)
   {
     op_queue<win_iocp_operation> ops;
     timer_queues_.get_all_timers(ops);
     ops.push(completed_ops_);
     if (!ops.empty())
     {
       while (win_iocp_operation* op = ops.front())
       {
         ops.pop();
         ::InterlockedDecrement(&outstanding_work_);
         op->destroy();
       }
     }
     else
     {
       DWORD bytes_transferred = 0;
       dword_ptr_t completion_key = 0;
       LPOVERLAPPED overlapped = 0;
       ::GetQueuedCompletionStatus(iocp_.handle, &bytes_transferred,
           &completion_key, &overlapped, gqcs_timeout);
       if (overlapped)
       {
         ::InterlockedDecrement(&outstanding_work_);
         static_cast<win_iocp_operation*>(overlapped)->destroy();
       }
     }
   }
 
-  if (timer_thread_.get())
+  if (timer_thread_)
     timer_thread_->join();
 }
 
 boost::system::error_code win_iocp_io_service::register_handle(
     HANDLE handle, boost::system::error_code& ec)
 {
   if (::CreateIoCompletionPort(handle, iocp_.handle, 0, 0) == 0)
   {
     DWORD last_error = ::GetLastError();
     ec = boost::system::error_code(last_error,
         boost::asio::error::get_system_category());
   }
   else
   {
     ec = boost::system::error_code();
   }
   return ec;
 }
 
 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);
 
   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);
 
   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);
 
   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);
 
   return do_one(false, ec);
 }
 
 void win_iocp_io_service::stop()
 {
   if (::InterlockedExchange(&stopped_, 1) == 0)
   {
     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))
   {
     // Out of resources. Put on completed queue instead.
     mutex::scoped_lock lock(dispatch_mutex_);
     completed_ops_.push(op);
     ::InterlockedExchange(&dispatch_required_, 1);
   }
 }
 
 void win_iocp_io_service::post_deferred_completions(
     op_queue<win_iocp_operation>& ops)
 {
   while (win_iocp_operation* op = ops.front())
   {
     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))
     {
       // 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);
     }
   }
 }
 
-void win_iocp_io_service::abandon_operations(
-    op_queue<win_iocp_operation>& ops)
-{
-  while (win_iocp_operation* op = ops.front())
-  {
-    ops.pop();
-    ::InterlockedDecrement(&outstanding_work_);
-    op->destroy();
-  }
-}
-
 void win_iocp_io_service::on_pending(win_iocp_operation* op)
 {
   if (::InterlockedCompareExchange(&op->ready_, 1, 0) == 1)
   {
     // Enqueue the operation on the I/O completion port.
     if (!::PostQueuedCompletionStatus(iocp_.handle,
           0, overlapped_contains_result, op))
     {
       // Out of resources. Put on completed queue instead.
       mutex::scoped_lock lock(dispatch_mutex_);
       completed_ops_.push(op);
       ::InterlockedExchange(&dispatch_required_, 1);
     }
   }
 }
 
 void win_iocp_io_service::on_completion(win_iocp_operation* op,
     DWORD last_error, DWORD bytes_transferred)
 {
   // Flag that the operation is ready for invocation.
   op->ready_ = 1;
 
   // Store results in the OVERLAPPED structure.
   op->Internal = reinterpret_cast<ulong_ptr_t>(
       &boost::asio::error::get_system_category());
   op->Offset = last_error;
   op->OffsetHigh = bytes_transferred;
 
   // Enqueue the operation on the I/O completion port.
   if (!::PostQueuedCompletionStatus(iocp_.handle,
         0, overlapped_contains_result, op))
   {
     // Out of resources. Put on completed queue instead.
     mutex::scoped_lock lock(dispatch_mutex_);
     completed_ops_.push(op);
@@ -433,77 +423,77 @@ size_t win_iocp_io_service::do_one(bool block, boost::system::error_code& ec)
               boost::asio::error::get_system_category());
           return 0;
         }
 
         ec = boost::system::error_code();
         return 0;
       }
     }
   }
 }
 
 void win_iocp_io_service::do_add_timer_queue(timer_queue_base& queue)
 {
   mutex::scoped_lock lock(dispatch_mutex_);
 
   timer_queues_.insert(&queue);
 
   if (!waitable_timer_.handle)
   {
     waitable_timer_.handle = ::CreateWaitableTimer(0, FALSE, 0);
     if (waitable_timer_.handle == 0)
     {
       DWORD last_error = ::GetLastError();
       boost::system::error_code ec(last_error,
           boost::asio::error::get_system_category());
       boost::asio::detail::throw_error(ec, "timer");
     }
 
     LARGE_INTEGER timeout;
     timeout.QuadPart = -max_timeout_usec;
     timeout.QuadPart *= 10;
     ::SetWaitableTimer(waitable_timer_.handle,
         &timeout, max_timeout_msec, 0, 0, FALSE);
   }
 
-  if (!timer_thread_.get())
+  if (!timer_thread_)
   {
     timer_thread_function thread_function = { this };
     timer_thread_.reset(new thread(thread_function, 65536));
   }
 }
 
 void win_iocp_io_service::do_remove_timer_queue(timer_queue_base& queue)
 {
   mutex::scoped_lock lock(dispatch_mutex_);
 
   timer_queues_.erase(&queue);
 }
 
 void win_iocp_io_service::update_timeout()
 {
-  if (timer_thread_.get())
+  if (timer_thread_)
   {
     // There's no point updating the waitable timer if the new timeout period
     // exceeds the maximum timeout. In that case, we might as well wait for the
     // existing period of the timer to expire.
     long timeout_usec = timer_queues_.wait_duration_usec(max_timeout_usec);
     if (timeout_usec < max_timeout_usec)
     {
       LARGE_INTEGER timeout;
       timeout.QuadPart = -timeout_usec;
       timeout.QuadPart *= 10;
       ::SetWaitableTimer(waitable_timer_.handle,
           &timeout, max_timeout_msec, 0, 0, FALSE);
     }
   }
 }
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // defined(BOOST_ASIO_HAS_IOCP)
 
 #endif // BOOST_ASIO_DETAIL_IMPL_WIN_IOCP_IO_SERVICE_IPP
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..32ab6d1 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,40 +1,40 @@
 //
 // detail/impl/win_iocp_serial_port_service.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2011 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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_IMPL_WIN_IOCP_SERIAL_PORT_SERVICE_IPP
 #define BOOST_ASIO_DETAIL_IMPL_WIN_IOCP_SERIAL_PORT_SERVICE_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_HAS_IOCP) && defined(BOOST_ASIO_HAS_SERIAL_PORT)
 
 #include <cstring>
 #include <boost/asio/detail/win_iocp_serial_port_service.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 win_iocp_serial_port_service::win_iocp_serial_port_service(
     boost::asio::io_service& io_service)
   : handle_service_(io_service)
 {
 }
 
 void win_iocp_serial_port_service::shutdown_service()
 {
 }
@@ -95,88 +95,88 @@ boost::system::error_code win_iocp_serial_port_service::open(
 
   // Set up timeouts so that the serial port will behave similarly to a
   // network socket. Reads wait for at least one byte, then return with
   // whatever they have. Writes return once everything is out the door.
   ::COMMTIMEOUTS timeouts;
   timeouts.ReadIntervalTimeout = 1;
   timeouts.ReadTotalTimeoutMultiplier = 0;
   timeouts.ReadTotalTimeoutConstant = 0;
   timeouts.WriteTotalTimeoutMultiplier = 0;
   timeouts.WriteTotalTimeoutConstant = 0;
   if (!::SetCommTimeouts(handle, &timeouts))
   {
     DWORD last_error = ::GetLastError();
     ::CloseHandle(handle);
     ec = boost::system::error_code(last_error,
         boost::asio::error::get_system_category());
     return ec;
   }
 
   // We're done. Take ownership of the serial port handle.
   if (handle_service_.assign(impl, handle, ec))
     ::CloseHandle(handle);
   return ec;
 }
 
 boost::system::error_code win_iocp_serial_port_service::do_set_option(
     win_iocp_serial_port_service::implementation_type& impl,
     win_iocp_serial_port_service::store_function_type store,
     const void* option, boost::system::error_code& ec)
 {
   using namespace std; // For memcpy.
 
   ::DCB dcb;
   memset(&dcb, 0, sizeof(DCB));
   dcb.DCBlength = sizeof(DCB);
-  if (!::GetCommState(handle_service_.native_handle(impl), &dcb))
+  if (!::GetCommState(handle_service_.native(impl), &dcb))
   {
     DWORD last_error = ::GetLastError();
     ec = boost::system::error_code(last_error,
         boost::asio::error::get_system_category());
     return ec;
   }
 
   if (store(option, dcb, ec))
     return ec;
 
-  if (!::SetCommState(handle_service_.native_handle(impl), &dcb))
+  if (!::SetCommState(handle_service_.native(impl), &dcb))
   {
     DWORD last_error = ::GetLastError();
     ec = boost::system::error_code(last_error,
         boost::asio::error::get_system_category());
     return ec;
   }
 
   ec = boost::system::error_code();
   return ec;
 }
 
 boost::system::error_code win_iocp_serial_port_service::do_get_option(
     const win_iocp_serial_port_service::implementation_type& impl,
     win_iocp_serial_port_service::load_function_type load,
     void* option, boost::system::error_code& ec) const
 {
   using namespace std; // For memset.
 
   ::DCB dcb;
   memset(&dcb, 0, sizeof(DCB));
   dcb.DCBlength = sizeof(DCB);
-  if (!::GetCommState(handle_service_.native_handle(impl), &dcb))
+  if (!::GetCommState(handle_service_.native(impl), &dcb))
   {
     DWORD last_error = ::GetLastError();
     ec = boost::system::error_code(last_error,
         boost::asio::error::get_system_category());
     return ec;
   }
 
   return load(option, dcb, ec);
 }
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // defined(BOOST_ASIO_HAS_IOCP) && defined(BOOST_ASIO_HAS_SERIAL_PORT)
 
 #endif // BOOST_ASIO_DETAIL_IMPL_WIN_IOCP_SERIAL_PORT_SERVICE_IPP
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..0a2825b 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,240 +1,162 @@
 //
 // detail/impl/win_iocp_socket_service_base.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_IMPL_WIN_IOCP_SOCKET_SERVICE_BASE_IPP
 #define BOOST_ASIO_DETAIL_IMPL_WIN_IOCP_SOCKET_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_HAS_IOCP)
 
 #include <boost/asio/detail/win_iocp_socket_service_base.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 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),
     mutex_(),
     impl_list_(0)
 {
 }
 
 void win_iocp_socket_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_for_destruction(*impl);
     impl = impl->next_;
   }
 }
 
 void win_iocp_socket_service_base::construct(
     win_iocp_socket_service_base::base_implementation_type& impl)
 {
   impl.socket_ = invalid_socket;
   impl.state_ = 0;
   impl.cancel_token_.reset();
 #if defined(BOOST_ASIO_ENABLE_CANCELIO)
   impl.safe_cancellation_thread_id_ = 0;
 #endif // defined(BOOST_ASIO_ENABLE_CANCELIO)
 
   // 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 win_iocp_socket_service_base::base_move_construct(
-    win_iocp_socket_service_base::base_implementation_type& impl,
-    win_iocp_socket_service_base::base_implementation_type& other_impl)
-{
-  impl.socket_ = other_impl.socket_;
-  other_impl.socket_ = invalid_socket;
-
-  impl.state_ = other_impl.state_;
-  other_impl.state_ = 0;
-
-  impl.cancel_token_ = other_impl.cancel_token_;
-  other_impl.cancel_token_.reset();
-
-#if defined(BOOST_ASIO_ENABLE_CANCELIO)
-  impl.safe_cancellation_thread_id_ = other_impl.safe_cancellation_thread_id_;
-  other_impl.safe_cancellation_thread_id_ = 0;
-#endif // defined(BOOST_ASIO_ENABLE_CANCELIO)
-
-  // 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 win_iocp_socket_service_base::base_move_assign(
-    win_iocp_socket_service_base::base_implementation_type& impl,
-    win_iocp_socket_service_base& other_service,
-    win_iocp_socket_service_base::base_implementation_type& other_impl)
-{
-  close_for_destruction(impl);
-
-  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_ = invalid_socket;
-
-  impl.state_ = other_impl.state_;
-  other_impl.state_ = 0;
-
-  impl.cancel_token_ = other_impl.cancel_token_;
-  other_impl.cancel_token_.reset();
-
-#if defined(BOOST_ASIO_ENABLE_CANCELIO)
-  impl.safe_cancellation_thread_id_ = other_impl.safe_cancellation_thread_id_;
-  other_impl.safe_cancellation_thread_id_ = 0;
-#endif // defined(BOOST_ASIO_ENABLE_CANCELIO)
-
-  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 win_iocp_socket_service_base::destroy(
     win_iocp_socket_service_base::base_implementation_type& impl)
 {
   close_for_destruction(impl);
 
   // 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 win_iocp_socket_service_base::close(
     win_iocp_socket_service_base::base_implementation_type& impl,
     boost::system::error_code& ec)
 {
   if (is_open(impl))
   {
-    BOOST_ASIO_HANDLER_OPERATION(("socket", &impl, "close"));
-
     // Check if the reactor was created, in which case we need to close the
     // socket on the reactor as well to cancel any operations that might be
     // running there.
     reactor* r = static_cast<reactor*>(
           interlocked_compare_exchange_pointer(
             reinterpret_cast<void**>(&reactor_), 0, 0));
     if (r)
-      r->deregister_descriptor(impl.socket_, impl.reactor_data_, true);
+      r->close_descriptor(impl.socket_, impl.reactor_data_);
   }
 
-  socket_ops::close(impl.socket_, impl.state_, false, ec);
-
-  impl.socket_ = invalid_socket;
-  impl.state_ = 0;
-  impl.cancel_token_.reset();
+  if (socket_ops::close(impl.socket_, impl.state_, false, ec) == 0)
+  {
+    impl.socket_ = invalid_socket;
+    impl.state_ = 0;
+    impl.cancel_token_.reset();
 #if defined(BOOST_ASIO_ENABLE_CANCELIO)
-  impl.safe_cancellation_thread_id_ = 0;
+    impl.safe_cancellation_thread_id_ = 0;
 #endif // defined(BOOST_ASIO_ENABLE_CANCELIO)
+  }
 
   return ec;
 }
 
 boost::system::error_code win_iocp_socket_service_base::cancel(
     win_iocp_socket_service_base::base_implementation_type& impl,
     boost::system::error_code& ec)
 {
   if (!is_open(impl))
   {
     ec = boost::asio::error::bad_descriptor;
     return ec;
   }
-
-  BOOST_ASIO_HANDLER_OPERATION(("socket", &impl, "cancel"));
-
-  if (FARPROC cancel_io_ex_ptr = ::GetProcAddress(
+  else if (FARPROC cancel_io_ex_ptr = ::GetProcAddress(
         ::GetModuleHandleA("KERNEL32"), "CancelIoEx"))
   {
     // The version of Windows supports cancellation from any thread.
     typedef BOOL (WINAPI* cancel_io_ex_t)(HANDLE, LPOVERLAPPED);
     cancel_io_ex_t cancel_io_ex = (cancel_io_ex_t)cancel_io_ex_ptr;
     socket_type sock = impl.socket_;
     HANDLE sock_as_handle = reinterpret_cast<HANDLE>(sock);
     if (!cancel_io_ex(sock_as_handle, 0))
     {
       DWORD last_error = ::GetLastError();
       if (last_error == ERROR_NOT_FOUND)
       {
         // ERROR_NOT_FOUND means that there were no operations to be
         // cancelled. We swallow this error to match the behaviour on other
         // platforms.
         ec = boost::system::error_code();
       }
       else
       {
         ec = boost::system::error_code(last_error,
             boost::asio::error::get_system_category());
       }
     }
     else
     {
       ec = boost::system::error_code();
     }
   }
 #if defined(BOOST_ASIO_ENABLE_CANCELIO)
   else if (impl.safe_cancellation_thread_id_ == 0)
   {
     // No operations have been started, so there's nothing to cancel.
     ec = boost::system::error_code();
   }
   else if (impl.safe_cancellation_thread_id_ == ::GetCurrentThreadId())
@@ -520,103 +442,101 @@ void win_iocp_socket_service_base::restart_accept_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);
   }
 }
 
 void win_iocp_socket_service_base::start_reactor_op(
     win_iocp_socket_service_base::base_implementation_type& impl,
     int op_type, reactor_op* 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);
     return;
   }
   else
     op->ec_ = boost::asio::error::bad_descriptor;
 
   iocp_service_.post_immediate_completion(op);
 }
 
 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)
 {
   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_))
+        impl.socket_, impl.state_, 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();
         r.start_op(reactor::connect_op, impl.socket_,
             impl.reactor_data_, op, false);
         return;
       }
     }
   }
 
   r.post_immediate_completion(op);
 }
 
 void win_iocp_socket_service_base::close_for_destruction(
     win_iocp_socket_service_base::base_implementation_type& impl)
 {
   if (is_open(impl))
   {
-    BOOST_ASIO_HANDLER_OPERATION(("socket", &impl, "close"));
-
     // Check if the reactor was created, in which case we need to close the
     // socket on the reactor as well to cancel any operations that might be
     // running there.
     reactor* r = static_cast<reactor*>(
           interlocked_compare_exchange_pointer(
             reinterpret_cast<void**>(&reactor_), 0, 0));
     if (r)
-      r->deregister_descriptor(impl.socket_, impl.reactor_data_, true);
+      r->close_descriptor(impl.socket_, impl.reactor_data_);
   }
 
   boost::system::error_code ignored_ec;
   socket_ops::close(impl.socket_, impl.state_, true, ignored_ec);
   impl.socket_ = invalid_socket;
   impl.state_ = 0;
   impl.cancel_token_.reset();
 #if defined(BOOST_ASIO_ENABLE_CANCELIO)
   impl.safe_cancellation_thread_id_ = 0;
 #endif // defined(BOOST_ASIO_ENABLE_CANCELIO)
 }
 
 void win_iocp_socket_service_base::update_cancellation_thread_id(
     win_iocp_socket_service_base::base_implementation_type& impl)
 {
 #if defined(BOOST_ASIO_ENABLE_CANCELIO)
   if (impl.safe_cancellation_thread_id_ == 0)
     impl.safe_cancellation_thread_id_ = ::GetCurrentThreadId();
   else if (impl.safe_cancellation_thread_id_ != ::GetCurrentThreadId())
     impl.safe_cancellation_thread_id_ = ~DWORD(0);
 #else // defined(BOOST_ASIO_ENABLE_CANCELIO)
   (void)impl;
 #endif // defined(BOOST_ASIO_ENABLE_CANCELIO)
 }
 
 reactor& win_iocp_socket_service_base::get_reactor()
 {
   reactor* r = static_cast<reactor*>(
         interlocked_compare_exchange_pointer(
           reinterpret_cast<void**>(&reactor_), 0, 0));
   if (!r)
   {
     r = &(use_service<reactor>(io_service_));
     interlocked_exchange_pointer(reinterpret_cast<void**>(&reactor_), r);
   }
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..af0d20e 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/win_mutex.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/win_mutex.ipp
@@ -1,40 +1,40 @@
 //
 // detail/impl/win_mutex.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_IMPL_WIN_MUTEX_IPP
 #define BOOST_ASIO_DETAIL_IMPL_WIN_MUTEX_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_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>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 win_mutex::win_mutex()
 {
   int error = do_init();
   boost::system::error_code ec(error,
       boost::asio::error::get_system_category());
   boost::asio::detail::throw_error(ec, "mutex");
 }
 
 int win_mutex::do_init()
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
deleted file mode 100644
index d91ccac..0000000
--- a/3rdParty/Boost/src/boost/asio/detail/impl/win_object_handle_service.ipp
+++ /dev/null
@@ -1,446 +0,0 @@
-//
-// detail/impl/win_object_handle_service.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2012 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)
-//
-
-#ifndef BOOST_ASIO_DETAIL_IMPL_WIN_OBJECT_HANDLE_SERVICE_IPP
-#define BOOST_ASIO_DETAIL_IMPL_WIN_OBJECT_HANDLE_SERVICE_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_HAS_WINDOWS_OBJECT_HANDLE)
-
-#include <boost/asio/detail/win_object_handle_service.hpp>
-
-#include <boost/asio/detail/push_options.hpp>
-
-namespace boost {
-namespace asio {
-namespace detail {
-
-win_object_handle_service::win_object_handle_service(
-    boost::asio::io_service& io_service)
-  : io_service_(boost::asio::use_service<io_service_impl>(io_service)),
-    mutex_(),
-    impl_list_(0),
-    shutdown_(false)
-{
-}
-
-void win_object_handle_service::shutdown_service()
-{
-  mutex::scoped_lock lock(mutex_);
-
-  // Setting this flag to true prevents new objects from being registered, and
-  // new asynchronous wait operations from being started. We only need to worry
-  // about cleaning up the operations that are currently in progress.
-  shutdown_ = true;
-
-  op_queue<operation> ops;
-  for (implementation_type* impl = impl_list_; impl; impl = impl->next_)
-    ops.push(impl->op_queue_);
-
-  lock.unlock();
-
-  io_service_.abandon_operations(ops);
-}
-
-void win_object_handle_service::construct(
-    win_object_handle_service::implementation_type& impl)
-{
-  impl.handle_ = INVALID_HANDLE_VALUE;
-  impl.wait_handle_ = INVALID_HANDLE_VALUE;
-  impl.owner_ = this;
-
-  // Insert implementation into linked list of all implementations.
-  mutex::scoped_lock lock(mutex_);
-  if (!shutdown_)
-  {
-    impl.next_ = impl_list_;
-    impl.prev_ = 0;
-    if (impl_list_)
-      impl_list_->prev_ = &impl;
-    impl_list_ = &impl;
-  }
-}
-
-void win_object_handle_service::move_construct(
-    win_object_handle_service::implementation_type& impl,
-    win_object_handle_service::implementation_type& other_impl)
-{
-  mutex::scoped_lock lock(mutex_);
-
-  // Insert implementation into linked list of all implementations.
-  if (!shutdown_)
-  {
-    impl.next_ = impl_list_;
-    impl.prev_ = 0;
-    if (impl_list_)
-      impl_list_->prev_ = &impl;
-    impl_list_ = &impl;
-  }
-
-  impl.handle_ = other_impl.handle_;
-  other_impl.handle_ = INVALID_HANDLE_VALUE;
-  impl.wait_handle_ = other_impl.wait_handle_;
-  other_impl.wait_handle_ = INVALID_HANDLE_VALUE;
-  impl.op_queue_.push(other_impl.op_queue_);
-  impl.owner_ = this;
-
-  // We must not hold the lock while calling UnregisterWaitEx. This is because
-  // the registered callback function might be invoked while we are waiting for
-  // UnregisterWaitEx to complete.
-  lock.unlock();
-
-  if (impl.wait_handle_ != INVALID_HANDLE_VALUE)
-    ::UnregisterWaitEx(impl.wait_handle_, INVALID_HANDLE_VALUE);
-
-  if (!impl.op_queue_.empty())
-    register_wait_callback(impl, lock);
-}
-
-void win_object_handle_service::move_assign(
-    win_object_handle_service::implementation_type& impl,
-    win_object_handle_service& other_service,
-    win_object_handle_service::implementation_type& other_impl)
-{
-  boost::system::error_code ignored_ec;
-  close(impl, ignored_ec);
-
-  mutex::scoped_lock lock(mutex_);
-
-  if (this != &other_service)
-  {
-    // Remove implementation from linked list of all implementations.
-    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.handle_ = other_impl.handle_;
-  other_impl.handle_ = INVALID_HANDLE_VALUE;
-  impl.wait_handle_ = other_impl.wait_handle_;
-  other_impl.wait_handle_ = INVALID_HANDLE_VALUE;
-  impl.op_queue_.push(other_impl.op_queue_);
-  impl.owner_ = this;
-
-  if (this != &other_service)
-  {
-    // Insert implementation into linked list of all implementations.
-    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;
-  }
-
-  // We must not hold the lock while calling UnregisterWaitEx. This is because
-  // the registered callback function might be invoked while we are waiting for
-  // UnregisterWaitEx to complete.
-  lock.unlock();
-
-  if (impl.wait_handle_ != INVALID_HANDLE_VALUE)
-    ::UnregisterWaitEx(impl.wait_handle_, INVALID_HANDLE_VALUE);
-
-  if (!impl.op_queue_.empty())
-    register_wait_callback(impl, lock);
-}
-
-void win_object_handle_service::destroy(
-    win_object_handle_service::implementation_type& impl)
-{
-  mutex::scoped_lock lock(mutex_);
-
-  // Remove implementation from linked list of all implementations.
-  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;
-
-  if (is_open(impl))
-  {
-    BOOST_ASIO_HANDLER_OPERATION(("object_handle", &impl, "close"));
-
-    HANDLE wait_handle = impl.wait_handle_;
-    impl.wait_handle_ = INVALID_HANDLE_VALUE;
-
-    op_queue<operation> ops;
-    while (wait_op* op = impl.op_queue_.front())
-    {
-      op->ec_ = boost::asio::error::operation_aborted;
-      impl.op_queue_.pop();
-      ops.push(op);
-    }
-
-    // We must not hold the lock while calling UnregisterWaitEx. This is
-    // because the registered callback function might be invoked while we are
-    // waiting for UnregisterWaitEx to complete.
-    lock.unlock();
-
-    if (wait_handle != INVALID_HANDLE_VALUE)
-      ::UnregisterWaitEx(wait_handle, INVALID_HANDLE_VALUE);
-
-    ::CloseHandle(impl.handle_);
-    impl.handle_ = INVALID_HANDLE_VALUE;
-
-    io_service_.post_deferred_completions(ops);
-  }
-}
-
-boost::system::error_code win_object_handle_service::assign(
-    win_object_handle_service::implementation_type& impl,
-    const native_handle_type& handle, boost::system::error_code& ec)
-{
-  if (is_open(impl))
-  {
-    ec = boost::asio::error::already_open;
-    return ec;
-  }
-
-  impl.handle_ = handle;
-  ec = boost::system::error_code();
-  return ec;
-}
-
-boost::system::error_code win_object_handle_service::close(
-    win_object_handle_service::implementation_type& impl,
-    boost::system::error_code& ec)
-{
-  if (is_open(impl))
-  {
-    BOOST_ASIO_HANDLER_OPERATION(("object_handle", &impl, "close"));
-
-    mutex::scoped_lock lock(mutex_);
-
-    HANDLE wait_handle = impl.wait_handle_;
-    impl.wait_handle_ = INVALID_HANDLE_VALUE;
-
-    op_queue<operation> completed_ops;
-    while (wait_op* op = impl.op_queue_.front())
-    {
-      impl.op_queue_.pop();
-      op->ec_ = boost::asio::error::operation_aborted;
-      completed_ops.push(op);
-    }
-
-    // We must not hold the lock while calling UnregisterWaitEx. This is
-    // because the registered callback function might be invoked while we are
-    // waiting for UnregisterWaitEx to complete.
-    lock.unlock();
-
-    if (wait_handle != INVALID_HANDLE_VALUE)
-      ::UnregisterWaitEx(wait_handle, INVALID_HANDLE_VALUE);
-
-    if (::CloseHandle(impl.handle_))
-    {
-      impl.handle_ = INVALID_HANDLE_VALUE;
-      ec = boost::system::error_code();
-    }
-    else
-    {
-      DWORD last_error = ::GetLastError();
-      ec = boost::system::error_code(last_error,
-          boost::asio::error::get_system_category());
-    }
-
-    io_service_.post_deferred_completions(completed_ops);
-  }
-  else
-  {
-    ec = boost::system::error_code();
-  }
-
-  return ec;
-}
-
-boost::system::error_code win_object_handle_service::cancel(
-    win_object_handle_service::implementation_type& impl,
-    boost::system::error_code& ec)
-{
-  if (is_open(impl))
-  {
-    BOOST_ASIO_HANDLER_OPERATION(("object_handle", &impl, "cancel"));
-
-    mutex::scoped_lock lock(mutex_);
-
-    HANDLE wait_handle = impl.wait_handle_;
-    impl.wait_handle_ = INVALID_HANDLE_VALUE;
-
-    op_queue<operation> completed_ops;
-    while (wait_op* op = impl.op_queue_.front())
-    {
-      op->ec_ = boost::asio::error::operation_aborted;
-      impl.op_queue_.pop();
-      completed_ops.push(op);
-    }
-
-    // We must not hold the lock while calling UnregisterWaitEx. This is
-    // because the registered callback function might be invoked while we are
-    // waiting for UnregisterWaitEx to complete.
-    lock.unlock();
-
-    if (wait_handle != INVALID_HANDLE_VALUE)
-      ::UnregisterWaitEx(wait_handle, INVALID_HANDLE_VALUE);
-
-    ec = boost::system::error_code();
-
-    io_service_.post_deferred_completions(completed_ops);
-  }
-  else
-  {
-    ec = boost::asio::error::bad_descriptor;
-  }
-
-  return ec;
-}
-
-void win_object_handle_service::wait(
-    win_object_handle_service::implementation_type& impl,
-    boost::system::error_code& ec)
-{
-  switch (::WaitForSingleObject(impl.handle_, INFINITE))
-  {
-  case WAIT_FAILED:
-    {
-      DWORD last_error = ::GetLastError();
-      ec = boost::system::error_code(last_error,
-          boost::asio::error::get_system_category());
-      break;
-    }
-  case WAIT_OBJECT_0:
-  case WAIT_ABANDONED:
-  default:
-    ec = boost::system::error_code();
-    break;
-  }
-}
-
-void win_object_handle_service::start_wait_op(
-    win_object_handle_service::implementation_type& impl, wait_op* op)
-{
-  io_service_.work_started();
-
-  if (is_open(impl))
-  {
-    mutex::scoped_lock lock(mutex_);
-
-    if (!shutdown_)
-    {
-      impl.op_queue_.push(op);
-
-      // Only the first operation to be queued gets to register a wait callback.
-      // Subsequent operations have to wait for the first to finish.
-      if (impl.op_queue_.front() == op)
-        register_wait_callback(impl, lock);
-    }
-    else
-    {
-      lock.unlock();
-      io_service_.post_deferred_completion(op);
-    }
-  }
-  else
-  {
-    op->ec_ = boost::asio::error::bad_descriptor;
-    io_service_.post_deferred_completion(op);
-  }
-}
-
-void win_object_handle_service::register_wait_callback(
-    win_object_handle_service::implementation_type& impl,
-    mutex::scoped_lock& lock)
-{
-  lock.lock();
-
-  if (!RegisterWaitForSingleObject(&impl.wait_handle_,
-        impl.handle_, &win_object_handle_service::wait_callback,
-        &impl, INFINITE, WT_EXECUTEONLYONCE))
-  {
-    DWORD last_error = ::GetLastError();
-    boost::system::error_code ec(last_error,
-        boost::asio::error::get_system_category());
-
-    op_queue<operation> completed_ops;
-    while (wait_op* op = impl.op_queue_.front())
-    {
-      op->ec_ = ec;
-      impl.op_queue_.pop();
-      completed_ops.push(op);
-    }
-
-    lock.unlock();
-    io_service_.post_deferred_completions(completed_ops);
-  }
-}
-
-void win_object_handle_service::wait_callback(PVOID param, BOOLEAN)
-{
-  implementation_type* impl = static_cast<implementation_type*>(param);
-  mutex::scoped_lock lock(impl->owner_->mutex_);
-
-  if (impl->wait_handle_ != INVALID_HANDLE_VALUE)
-  {
-    ::UnregisterWaitEx(impl->wait_handle_, NULL);
-    impl->wait_handle_ = INVALID_HANDLE_VALUE;
-  }
-
-  if (wait_op* op = impl->op_queue_.front())
-  {
-    op_queue<operation> completed_ops;
-
-    op->ec_ = boost::system::error_code();
-    impl->op_queue_.pop();
-    completed_ops.push(op);
-
-    if (!impl->op_queue_.empty())
-    {
-      if (!RegisterWaitForSingleObject(&impl->wait_handle_,
-            impl->handle_, &win_object_handle_service::wait_callback,
-            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())
-        {
-          op->ec_ = ec;
-          impl->op_queue_.pop();
-          completed_ops.push(op);
-        }
-      }
-    }
-
-    lock.unlock();
-    impl->owner_->io_service_.post_deferred_completions(completed_ops);
-  }
-}
-
-} // namespace detail
-} // namespace asio
-} // namespace boost
-
-#include <boost/asio/detail/pop_options.hpp>
-
-#endif // defined(BOOST_ASIO_HAS_WINDOWS_OBJECT_HANDLE)
-
-#endif // BOOST_ASIO_DETAIL_IMPL_WIN_OBJECT_HANDLE_SERVICE_IPP
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
deleted file mode 100644
index 3ec104d..0000000
--- a/3rdParty/Boost/src/boost/asio/detail/impl/win_static_mutex.ipp
+++ /dev/null
@@ -1,120 +0,0 @@
-//
-// detail/impl/win_static_mutex.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// 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_IMPL_WIN_STATIC_MUTEX_IPP
-#define BOOST_ASIO_DETAIL_IMPL_WIN_STATIC_MUTEX_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_WINDOWS)
-
-#include <cstdio>
-#include <boost/asio/detail/throw_error.hpp>
-#include <boost/asio/detail/win_static_mutex.hpp>
-#include <boost/asio/error.hpp>
-
-#include <boost/asio/detail/push_options.hpp>
-
-namespace boost {
-namespace asio {
-namespace detail {
-
-void win_static_mutex::init()
-{
-  int error = do_init();
-  boost::system::error_code ec(error,
-      boost::asio::error::get_system_category());
-  boost::asio::detail::throw_error(ec, "static_mutex");
-}
-
-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",
-      static_cast<unsigned int>(::GetCurrentProcessId()), this);
-
-  HANDLE mutex = ::CreateMutexW(0, TRUE, mutex_name);
-  DWORD last_error = ::GetLastError();
-  if (mutex == 0)
-    return ::GetLastError();
-
-  if (last_error == ERROR_ALREADY_EXISTS)
-    ::WaitForSingleObject(mutex, INFINITE);
-
-  if (initialised_)
-  {
-    ::ReleaseMutex(mutex);
-    ::CloseHandle(mutex);
-    return 0;
-  }
-
-#if defined(__MINGW32__)
-  // Not sure if MinGW supports structured exception handling, so for now
-  // we'll just call the Windows API and hope.
-# if defined(UNDER_CE)
-  ::InitializeCriticalSection(&crit_section_);
-# else
-  if (!::InitializeCriticalSectionAndSpinCount(&crit_section_, 0x80000000))
-  {
-    last_error = ::GetLastError();
-    ::ReleaseMutex(mutex);
-    ::CloseHandle(mutex);
-    return last_error;
-  }
-# endif
-#else
-  __try
-  {
-# if defined(UNDER_CE)
-    ::InitializeCriticalSection(&crit_section_);
-# else
-    if (!::InitializeCriticalSectionAndSpinCount(&crit_section_, 0x80000000))
-    {
-      last_error = ::GetLastError();
-      ::ReleaseMutex(mutex);
-      ::CloseHandle(mutex);
-      return last_error;
-    }
-# endif
-  }
-  __except(GetExceptionCode() == STATUS_NO_MEMORY
-      ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
-  {
-    ::ReleaseMutex(mutex);
-    ::CloseHandle(mutex);
-    return ERROR_OUTOFMEMORY;
-  }
-#endif
-
-  initialised_ = true;
-  ::ReleaseMutex(mutex);
-  ::CloseHandle(mutex);
-  return 0;
-}
-
-} // namespace detail
-} // namespace asio
-} // namespace boost
-
-#include <boost/asio/detail/pop_options.hpp>
-
-#endif // defined(BOOST_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..07cc5c2 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/win_thread.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/win_thread.ipp
@@ -1,40 +1,40 @@
 //
 // detail/impl/win_thread.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_IMPL_WIN_THREAD_IPP
 #define BOOST_ASIO_DETAIL_IMPL_WIN_THREAD_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_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>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 win_thread::~win_thread()
 {
   ::CloseHandle(thread_);
 
   // The exit_event_ handle is deliberately allowed to leak here since it
   // is an error for the owner of an internal thread not to join() it.
 }
 
@@ -70,72 +70,71 @@ void win_thread::start_thread(func_base* arg, unsigned int stack_size)
   arg->exit_event_ = exit_event_ = ::CreateEvent(0, true, false, 0);
   if (!exit_event_)
   {
     DWORD last_error = ::GetLastError();
     delete arg;
     boost::system::error_code ec(last_error,
         boost::asio::error::get_system_category());
     boost::asio::detail::throw_error(ec, "thread.exit_event");
   }
 
   unsigned int thread_id = 0;
   thread_ = reinterpret_cast<HANDLE>(::_beginthreadex(0,
         stack_size, win_thread_function, arg, 0, &thread_id));
   if (!thread_)
   {
     DWORD last_error = ::GetLastError();
     delete arg;
     if (entry_event)
       ::CloseHandle(entry_event);
     if (exit_event_)
       ::CloseHandle(exit_event_);
     boost::system::error_code ec(last_error,
         boost::asio::error::get_system_category());
     boost::asio::detail::throw_error(ec, "thread");
   }
 
   if (entry_event)
   {
     ::WaitForSingleObject(entry_event, INFINITE);
     ::CloseHandle(entry_event);
   }
 }
 
 unsigned int __stdcall win_thread_function(void* arg)
 {
-  win_thread::auto_func_base_ptr func = {
-      static_cast<win_thread::func_base*>(arg) };
+  std::auto_ptr<win_thread::func_base> func(
+      static_cast<win_thread::func_base*>(arg));
 
-  ::SetEvent(func.ptr->entry_event_);
+  ::SetEvent(func->entry_event_);
 
-  func.ptr->run();
+  func->run();
 
   // Signal that the thread has finished its work, but rather than returning go
   // to sleep to put the thread into a well known state. If the thread is being
   // joined during global object destruction then it may be killed using
   // TerminateThread (to avoid a deadlock in DllMain). Otherwise, the SleepEx
   // call will be interrupted using QueueUserAPC and the thread will shut down
   // cleanly.
-  HANDLE exit_event = func.ptr->exit_event_;
-  delete func.ptr;
-  func.ptr = 0;
+  HANDLE exit_event = func->exit_event_;
+  func.reset();
   ::SetEvent(exit_event);
   ::SleepEx(INFINITE, TRUE);
 
   return 0;
 }
 
 #if defined(WINVER) && (WINVER < 0x0500)
 void __stdcall apc_function(ULONG) {}
 #else
 void __stdcall apc_function(ULONG_PTR) {}
 #endif
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // defined(BOOST_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..02abd55 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,40 +1,40 @@
 //
 // detail/impl/win_tss_ptr.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_IMPL_WIN_TSS_PTR_IPP
 #define BOOST_ASIO_DETAIL_IMPL_WIN_TSS_PTR_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_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>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 DWORD win_tss_ptr_create()
 {
 #if defined(UNDER_CE)
   enum { out_of_indexes = 0xFFFFFFFF };
 #else
   enum { out_of_indexes = TLS_OUT_OF_INDEXES };
 #endif
 
   DWORD tss_key = ::TlsAlloc();
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..e8fd647 100644
--- a/3rdParty/Boost/src/boost/asio/detail/impl/winsock_init.ipp
+++ b/3rdParty/Boost/src/boost/asio/detail/impl/winsock_init.ipp
@@ -1,40 +1,40 @@
 //
 // detail/impl/winsock_init.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_IMPL_WINSOCK_INIT_IPP
 #define BOOST_ASIO_DETAIL_IMPL_WINSOCK_INIT_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_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>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 void winsock_init_base::startup(data& d,
     unsigned char major, unsigned char minor)
 {
   if (::InterlockedIncrement(&d.init_count_) == 1)
   {
     WSADATA wsa_data;
     long result = ::WSAStartup(MAKEWORD(major, minor), &wsa_data);
     ::InterlockedExchange(&d.result_, result);
diff --git a/3rdParty/Boost/src/boost/asio/detail/io_control.hpp b/3rdParty/Boost/src/boost/asio/detail/io_control.hpp
index e08a4fc..c63e6e5 100644
--- a/3rdParty/Boost/src/boost/asio/detail/io_control.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/io_control.hpp
@@ -1,134 +1,134 @@
 //
 // detail/io_control.hpp
 // ~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_IO_CONTROL_HPP
 #define BOOST_ASIO_DETAIL_IO_CONTROL_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/config.hpp>
 #include <boost/asio/detail/socket_types.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 namespace io_control {
 
 // IO control command for non-blocking I/O.
 class non_blocking_io
 {
 public:
   // Default constructor.
   non_blocking_io()
     : value_(0)
   {
   }
 
   // Construct with a specific command value.
   non_blocking_io(bool value)
     : value_(value ? 1 : 0)
   {
   }
 
   // Get the name of the IO control command.
   int name() const
   {
-    return static_cast<int>(FIONBIO);
+    return FIONBIO;
   }
 
   // Set the value of the I/O control command.
   void set(bool value)
   {
     value_ = value ? 1 : 0;
   }
 
   // Get the current value of the I/O control command.
   bool get() const
   {
     return value_ != 0;
   }
 
   // Get the address of the command data.
   detail::ioctl_arg_type* data()
   {
     return &value_;
   }
 
   // Get the address of the command data.
   const detail::ioctl_arg_type* data() const
   {
     return &value_;
   }
 
 private:
   detail::ioctl_arg_type value_;
 };
 
 // I/O control command for getting number of bytes available.
 class bytes_readable
 {
 public:
   // Default constructor.
   bytes_readable()
     : value_(0)
   {
   }
 
   // Construct with a specific command value.
   bytes_readable(std::size_t value)
     : value_(static_cast<detail::ioctl_arg_type>(value))
   {
   }
 
   // Get the name of the IO control command.
   int name() const
   {
-    return static_cast<int>(FIONREAD);
+    return FIONREAD;
   }
 
   // Set the value of the I/O control command.
   void set(std::size_t value)
   {
     value_ = static_cast<detail::ioctl_arg_type>(value);
   }
 
   // Get the current value of the I/O control command.
   std::size_t get() const
   {
     return static_cast<std::size_t>(value_);
   }
 
   // Get the address of the command data.
   detail::ioctl_arg_type* data()
   {
     return &value_;
   }
 
   // Get the address of the command data.
   const detail::ioctl_arg_type* data() const
   {
     return &value_;
   }
 
 private:
   detail::ioctl_arg_type value_;
 };
 
 } // namespace io_control
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
diff --git a/3rdParty/Boost/src/boost/asio/detail/keyword_tss_ptr.hpp b/3rdParty/Boost/src/boost/asio/detail/keyword_tss_ptr.hpp
deleted file mode 100644
index 10dd01a..0000000
--- a/3rdParty/Boost/src/boost/asio/detail/keyword_tss_ptr.hpp
+++ /dev/null
@@ -1,72 +0,0 @@
-//
-// detail/keyword_tss_ptr.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_KEYWORD_TSS_PTR_HPP
-#define BOOST_ASIO_DETAIL_KEYWORD_TSS_PTR_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_THREAD_KEYWORD_EXTENSION)
-
-#include <boost/asio/detail/noncopyable.hpp>
-
-#include <boost/asio/detail/push_options.hpp>
-
-namespace boost {
-namespace asio {
-namespace detail {
-
-template <typename T>
-class keyword_tss_ptr
-  : private noncopyable
-{
-public:
-  // Constructor.
-  keyword_tss_ptr()
-  {
-  }
-
-  // Destructor.
-  ~keyword_tss_ptr()
-  {
-  }
-
-  // Get the value.
-  operator T*() const
-  {
-    return value_;
-  }
-
-  // Set the value.
-  void operator=(T* value)
-  {
-    value_ = value;
-  }
-
-private:
-  static __thread T* value_;
-};
-
-template <typename T>
-__thread T* keyword_tss_ptr<T>::value_;
-
-} // namespace detail
-} // namespace asio
-} // namespace boost
-
-#include <boost/asio/detail/pop_options.hpp>
-
-#endif // defined(BOOST_ASIO_HAS_THREAD_KEYWORD_EXTENSION)
-
-#endif // BOOST_ASIO_DETAIL_KEYWORD_TSS_PTR_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..80f7ca3 100644
--- a/3rdParty/Boost/src/boost/asio/detail/kqueue_reactor.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/kqueue_reactor.hpp
@@ -1,210 +1,180 @@
 //
 // detail/kqueue_reactor.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2011 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_HPP
 #define BOOST_ASIO_DETAIL_KQUEUE_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_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/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_op.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.
 #if !defined(EV_OOBAND)
 # define EV_OOBAND EV_FLAG1
 #endif // !defined(EV_OOBAND)
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 class kqueue_reactor
   : public boost::asio::detail::service_base<kqueue_reactor>
 {
 public:
   enum op_types { read_op = 0, write_op = 1,
     connect_op = 1, except_op = 2, max_ops = 3 };
 
   // Per-descriptor queues.
   struct descriptor_state
   {
     friend class kqueue_reactor;
     friend class object_pool_access;
-
-    descriptor_state* next_;
-    descriptor_state* prev_;
-
     mutex mutex_;
-    int descriptor_;
     op_queue<reactor_op> op_queue_[max_ops];
     bool shutdown_;
+    descriptor_state* next_;
+    descriptor_state* prev_;
   };
 
   // Per-descriptor data.
   typedef descriptor_state* per_descriptor_data;
 
   // Constructor.
   BOOST_ASIO_DECL kqueue_reactor(boost::asio::io_service& io_service);
 
   // Destructor.
   BOOST_ASIO_DECL ~kqueue_reactor();
 
   // 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.
   BOOST_ASIO_DECL void init_task();
 
   // Register a socket with the reactor. Returns 0 on success, system error
   // code on failure.
   BOOST_ASIO_DECL int register_descriptor(socket_type descriptor,
       per_descriptor_data& descriptor_data);
 
-  // Register a descriptor with an associated single operation. Returns 0 on
-  // 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);
-
-  // 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)
   {
     io_service_.post_immediate_completion(op);
   }
 
   // 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);
 
   // 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);
 
   // Cancel any operations that are running against the descriptor and remove
   // its registration from the reactor.
-  BOOST_ASIO_DECL void deregister_descriptor(socket_type descriptor,
-      per_descriptor_data& descriptor_data, bool closing);
-
-  // Remote the descriptor's registration from the reactor.
-  BOOST_ASIO_DECL void deregister_internal_descriptor(
-      socket_type descriptor, per_descriptor_data& descriptor_data);
+  BOOST_ASIO_DECL void close_descriptor(socket_type descriptor,
+      per_descriptor_data& descriptor_data);
 
   // 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);
+      typename timer_queue<Time_Traits>::per_timer_data& timer, timer_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)());
+      typename timer_queue<Time_Traits>::per_timer_data& timer);
 
   // Run the kqueue loop.
   BOOST_ASIO_DECL void run(bool block, op_queue<operation>& ops);
 
   // Interrupt the kqueue loop.
   BOOST_ASIO_DECL void interrupt();
 
 private:
   // Create the kqueue file descriptor. Throws an exception if the descriptor
   // cannot be created.
   BOOST_ASIO_DECL static int do_kqueue_create();
 
-  // Allocate a new descriptor state object.
-  BOOST_ASIO_DECL descriptor_state* allocate_descriptor_state();
-
-  // Free an existing descriptor state object.
-  BOOST_ASIO_DECL void free_descriptor_state(descriptor_state* s);
-
   // 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);
 
   // Get the timeout value for the kevent call.
   BOOST_ASIO_DECL timespec* get_timeout(timespec& ts);
 
   // The io_service implementation used to post completions.
   io_service_impl& io_service_;
 
   // Mutex to protect access to internal data.
   mutex mutex_;
 
   // The kqueue file descriptor.
   int kqueue_fd_;
 
   // The interrupter is used to break a blocking kevent call.
   select_interrupter interrupter_;
 
   // The timer queues.
   timer_queue_set timer_queues_;
 
   // Whether the service has been shut down.
   bool shutdown_;
 
   // Mutex to protect access to the registered descriptors.
   mutex registered_descriptors_mutex_;
 
   // Keep track of all registered descriptors.
   object_pool<descriptor_state> registered_descriptors_;
 };
 
 } // namespace detail
diff --git a/3rdParty/Boost/src/boost/asio/detail/kqueue_reactor_fwd.hpp b/3rdParty/Boost/src/boost/asio/detail/kqueue_reactor_fwd.hpp
index 517a307..1bceb30 100644
--- a/3rdParty/Boost/src/boost/asio/detail/kqueue_reactor_fwd.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/kqueue_reactor_fwd.hpp
@@ -1,35 +1,35 @@
 //
 // detail/kqueue_reactor_fwd.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2011 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/macos_fenced_block.hpp b/3rdParty/Boost/src/boost/asio/detail/macos_fenced_block.hpp
index dc3b47d..d37eea6 100644
--- a/3rdParty/Boost/src/boost/asio/detail/macos_fenced_block.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/macos_fenced_block.hpp
@@ -1,63 +1,55 @@
 //
 // detail/macos_fenced_block.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_MACOS_FENCED_BLOCK_HPP
 #define BOOST_ASIO_DETAIL_MACOS_FENCED_BLOCK_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(__MACH__) && defined(__APPLE__)
 
 #include <libkern/OSAtomic.h>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 class macos_fenced_block
   : private noncopyable
 {
 public:
-  enum half_t { half };
-  enum full_t { full };
-
-  // Constructor for a half fenced block.
-  explicit macos_fenced_block(half_t)
-  {
-  }
-
-  // Constructor for a full fenced block.
-  explicit macos_fenced_block(full_t)
+  // Constructor.
+  macos_fenced_block()
   {
     OSMemoryBarrier();
   }
 
   // Destructor.
   ~macos_fenced_block()
   {
     OSMemoryBarrier();
   }
 };
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // defined(__MACH__) && defined(__APPLE__)
 
 #endif // 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..988dd3a 100644
--- a/3rdParty/Boost/src/boost/asio/detail/mutex.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/mutex.hpp
@@ -1,40 +1,40 @@
 //
 // detail/mutex.hpp
 // ~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_MUTEX_HPP
 #define BOOST_ASIO_DETAIL_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_HAS_THREADS) || defined(BOOST_ASIO_DISABLE_THREADS)
 # include <boost/asio/detail/null_mutex.hpp>
 #elif defined(BOOST_WINDOWS)
 # include <boost/asio/detail/win_mutex.hpp>
 #elif defined(BOOST_HAS_PTHREADS)
 # include <boost/asio/detail/posix_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)
 typedef null_mutex mutex;
 #elif defined(BOOST_WINDOWS)
 typedef win_mutex mutex;
 #elif defined(BOOST_HAS_PTHREADS)
 typedef posix_mutex mutex;
 #endif
diff --git a/3rdParty/Boost/src/boost/asio/detail/noncopyable.hpp b/3rdParty/Boost/src/boost/asio/detail/noncopyable.hpp
index 5f7e8cc..234ce93 100644
--- a/3rdParty/Boost/src/boost/asio/detail/noncopyable.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/noncopyable.hpp
@@ -1,40 +1,40 @@
 //
 // detail/noncopyable.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_NONCOPYABLE_HPP
 #define BOOST_ASIO_DETAIL_NONCOPYABLE_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/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_;
diff --git a/3rdParty/Boost/src/boost/asio/detail/null_event.hpp b/3rdParty/Boost/src/boost/asio/detail/null_event.hpp
index 1130d18..7f079ae 100644
--- a/3rdParty/Boost/src/boost/asio/detail/null_event.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/null_event.hpp
@@ -1,40 +1,40 @@
 //
 // detail/null_event.hpp
 // ~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_NULL_EVENT_HPP
 #define BOOST_ASIO_DETAIL_NULL_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_HAS_THREADS) || defined(BOOST_ASIO_DISABLE_THREADS)
 
 #include <boost/asio/detail/noncopyable.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 class null_event
   : private noncopyable
 {
 public:
   // Constructor.
   null_event()
   {
   }
 
   // Destructor.
   ~null_event()
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..70680c5 100644
--- a/3rdParty/Boost/src/boost/asio/detail/null_fenced_block.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/null_fenced_block.hpp
@@ -1,47 +1,45 @@
 //
 // detail/null_fenced_block.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_NULL_FENCED_BLOCK_HPP
 #define BOOST_ASIO_DETAIL_NULL_FENCED_BLOCK_HPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 class null_fenced_block
   : private noncopyable
 {
 public:
-  enum half_or_full_t { half, full };
-
   // Constructor.
-  explicit null_fenced_block(half_or_full_t)
+  null_fenced_block()
   {
   }
 
   // Destructor.
   ~null_fenced_block()
   {
   }
 };
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // 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..e095e01 100644
--- a/3rdParty/Boost/src/boost/asio/detail/null_mutex.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/null_mutex.hpp
@@ -1,40 +1,40 @@
 //
 // detail/null_mutex.hpp
 // ~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_NULL_MUTEX_HPP
 #define BOOST_ASIO_DETAIL_NULL_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_HAS_THREADS) || defined(BOOST_ASIO_DISABLE_THREADS)
 
 #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 null_mutex
   : private noncopyable
 {
 public:
   typedef boost::asio::detail::scoped_lock<null_mutex> scoped_lock;
 
   // Constructor.
   null_mutex()
   {
   }
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..bcf813b 100644
--- a/3rdParty/Boost/src/boost/asio/detail/null_signal_blocker.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/null_signal_blocker.hpp
@@ -1,40 +1,40 @@
 //
 // detail/null_signal_blocker.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_NULL_SIGNAL_BLOCKER_HPP
 #define BOOST_ASIO_DETAIL_NULL_SIGNAL_BLOCKER_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_HAS_THREADS) \
   || defined(BOOST_ASIO_DISABLE_THREADS) \
   || defined(BOOST_WINDOWS) \
   || defined(__CYGWIN__) \
   || defined(__SYMBIAN32__)
 
 #include <boost/asio/detail/noncopyable.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 class null_signal_blocker
   : private noncopyable
 {
 public:
   // Constructor blocks all signals for the calling thread.
   null_signal_blocker()
   {
diff --git a/3rdParty/Boost/src/boost/asio/detail/null_static_mutex.hpp b/3rdParty/Boost/src/boost/asio/detail/null_static_mutex.hpp
deleted file mode 100644
index 3032896..0000000
--- a/3rdParty/Boost/src/boost/asio/detail/null_static_mutex.hpp
+++ /dev/null
@@ -1,62 +0,0 @@
-//
-// detail/null_static_mutex.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_NULL_STATIC_MUTEX_HPP
-#define BOOST_ASIO_DETAIL_NULL_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_HAS_THREADS) || defined(BOOST_ASIO_DISABLE_THREADS)
-
-#include <boost/asio/detail/scoped_lock.hpp>
-
-#include <boost/asio/detail/push_options.hpp>
-
-namespace boost {
-namespace asio {
-namespace detail {
-
-struct null_static_mutex
-{
-  typedef boost::asio::detail::scoped_lock<null_static_mutex> scoped_lock;
-
-  // Initialise the mutex.
-  void init()
-  {
-  }
-
-  // Lock the mutex.
-  void lock()
-  {
-  }
-
-  // Unlock the mutex.
-  void unlock()
-  {
-  }
-
-  int unused_;
-};
-
-#define BOOST_ASIO_NULL_STATIC_MUTEX_INIT { 0 }
-
-} // namespace detail
-} // namespace asio
-} // namespace boost
-
-#include <boost/asio/detail/pop_options.hpp>
-
-#endif // !defined(BOOST_HAS_THREADS) || defined(BOOST_ASIO_DISABLE_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..ae32014 100644
--- a/3rdParty/Boost/src/boost/asio/detail/null_thread.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/null_thread.hpp
@@ -1,40 +1,40 @@
 //
 // detail/null_thread.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_NULL_THREAD_HPP
 #define BOOST_ASIO_DETAIL_NULL_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_HAS_THREADS) || defined(BOOST_ASIO_DISABLE_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>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 class null_thread
   : private noncopyable
 {
 public:
   // Constructor.
   template <typename Function>
   null_thread(Function, unsigned int = 0)
   {
     boost::asio::detail::throw_error(
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..c44b4de 100644
--- a/3rdParty/Boost/src/boost/asio/detail/null_tss_ptr.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/null_tss_ptr.hpp
@@ -1,40 +1,40 @@
 //
 // detail/null_tss_ptr.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_NULL_TSS_PTR_HPP
 #define BOOST_ASIO_DETAIL_NULL_TSS_PTR_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_HAS_THREADS) || defined(BOOST_ASIO_DISABLE_THREADS)
 
 #include <boost/asio/detail/noncopyable.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 template <typename T>
 class null_tss_ptr
   : private noncopyable
 {
 public:
   // Constructor.
   null_tss_ptr()
     : value_(0)
   {
   }
 
diff --git a/3rdParty/Boost/src/boost/asio/detail/object_pool.hpp b/3rdParty/Boost/src/boost/asio/detail/object_pool.hpp
index d315236..69790a0 100644
--- a/3rdParty/Boost/src/boost/asio/detail/object_pool.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/object_pool.hpp
@@ -1,40 +1,40 @@
 //
 // detail/object_pool.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_OBJECT_POOL_HPP
 #define BOOST_ASIO_DETAIL_OBJECT_POOL_HPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/noncopyable.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 template <typename Object>
 class object_pool;
 
 class object_pool_access
 {
 public:
   template <typename Object>
   static Object* create()
   {
     return new Object;
   }
 
   template <typename Object>
   static void destroy(Object* o)
   {
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..d385d3e 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,40 +1,40 @@
 //
 // detail/old_win_sdk_compat.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_OLD_WIN_SDK_COMPAT_HPP
 #define BOOST_ASIO_DETAIL_OLD_WIN_SDK_COMPAT_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_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)
 
 #if defined(BOOST_ASIO_HAS_OLD_WIN_SDK)
 
 // Emulation of types that are missing from old Platform SDKs.
 //
 // N.B. this emulation is also used if building for a Windows 2000 target with
 // a recent (i.e. Vista or later) SDK, as the SDK does not provide IPv6 support
 // in that case.
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
@@ -53,70 +53,78 @@ struct sockaddr_storage_emulation
   char __ss_pad1[sockaddr_storage_pad1size];
   __int64 __ss_align;
   char __ss_pad2[sockaddr_storage_pad2size];
 };
 
 struct in6_addr_emulation
 {
   union
   {
     u_char Byte[16];
     u_short Word[8];
   } u;
 };
 
 #if !defined(s6_addr)
 # define _S6_un u
 # define _S6_u8 Byte
 # define s6_addr _S6_un._S6_u8
 #endif // !defined(s6_addr)
 
 struct sockaddr_in6_emulation
 {
   short sin6_family;
   u_short sin6_port;
   u_long sin6_flowinfo;
   in6_addr_emulation sin6_addr;
   u_long sin6_scope_id;
 };
 
 struct ipv6_mreq_emulation
 {
   in6_addr_emulation ipv6mr_multiaddr;
   unsigned int ipv6mr_interface;
 };
 
+#if !defined(IN6ADDR_ANY_INIT)
+# define IN6ADDR_ANY_INIT { 0 }
+#endif
+
+#if !defined(IN6ADDR_LOOPBACK_INIT)
+# define IN6ADDR_LOOPBACK_INIT { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 }
+#endif
+
 struct addrinfo_emulation
 {
   int ai_flags;
   int ai_family;
   int ai_socktype;
   int ai_protocol;
   size_t ai_addrlen;
   char* ai_canonname;
   sockaddr* ai_addr;
   addrinfo_emulation* ai_next;
 };
 
 #if !defined(AI_PASSIVE)
 # define AI_PASSIVE 0x1
 #endif
 
 #if !defined(AI_CANONNAME)
 # define AI_CANONNAME 0x2
 #endif
 
 #if !defined(AI_NUMERICHOST)
 # define AI_NUMERICHOST 0x4
 #endif
 
 #if !defined(EAI_AGAIN)
 # define EAI_AGAIN WSATRY_AGAIN
 #endif
 
 #if !defined(EAI_BADFLAGS)
 # define EAI_BADFLAGS WSAEINVAL
 #endif
 
 #if !defined(EAI_FAIL)
 # define EAI_FAIL WSANO_RECOVERY
 #endif
@@ -161,56 +169,172 @@ struct addrinfo_emulation
 # define NI_NUMERICSERV 0x08
 #endif
 
 #if !defined(NI_DGRAM)
 # define NI_DGRAM 0x10
 #endif
 
 #if !defined(IPPROTO_IPV6)
 # define IPPROTO_IPV6 41
 #endif
 
 #if !defined(IPV6_UNICAST_HOPS)
 # define IPV6_UNICAST_HOPS 4
 #endif
 
 #if !defined(IPV6_MULTICAST_IF)
 # define IPV6_MULTICAST_IF 9
 #endif
 
 #if !defined(IPV6_MULTICAST_HOPS)
 # define IPV6_MULTICAST_HOPS 10
 #endif
 
 #if !defined(IPV6_MULTICAST_LOOP)
 # define IPV6_MULTICAST_LOOP 11
 #endif
 
 #if !defined(IPV6_JOIN_GROUP)
 # define IPV6_JOIN_GROUP 12
 #endif
 
 #if !defined(IPV6_LEAVE_GROUP)
 # define IPV6_LEAVE_GROUP 13
 #endif
 
+inline int IN6_IS_ADDR_UNSPECIFIED(const in6_addr_emulation* a)
+{
+  return ((a->s6_addr[0] == 0)
+      && (a->s6_addr[1] == 0)
+      && (a->s6_addr[2] == 0)
+      && (a->s6_addr[3] == 0)
+      && (a->s6_addr[4] == 0)
+      && (a->s6_addr[5] == 0)
+      && (a->s6_addr[6] == 0)
+      && (a->s6_addr[7] == 0)
+      && (a->s6_addr[8] == 0)
+      && (a->s6_addr[9] == 0)
+      && (a->s6_addr[10] == 0)
+      && (a->s6_addr[11] == 0)
+      && (a->s6_addr[12] == 0)
+      && (a->s6_addr[13] == 0)
+      && (a->s6_addr[14] == 0)
+      && (a->s6_addr[15] == 0));
+}
+
+inline int IN6_IS_ADDR_LOOPBACK(const in6_addr_emulation* a)
+{
+  return ((a->s6_addr[0] == 0)
+      && (a->s6_addr[1] == 0)
+      && (a->s6_addr[2] == 0)
+      && (a->s6_addr[3] == 0)
+      && (a->s6_addr[4] == 0)
+      && (a->s6_addr[5] == 0)
+      && (a->s6_addr[6] == 0)
+      && (a->s6_addr[7] == 0)
+      && (a->s6_addr[8] == 0)
+      && (a->s6_addr[9] == 0)
+      && (a->s6_addr[10] == 0)
+      && (a->s6_addr[11] == 0)
+      && (a->s6_addr[12] == 0)
+      && (a->s6_addr[13] == 0)
+      && (a->s6_addr[14] == 0)
+      && (a->s6_addr[15] == 1));
+}
+
+inline int IN6_IS_ADDR_MULTICAST(const in6_addr_emulation* a)
+{
+  return (a->s6_addr[0] == 0xff);
+}
+
+inline int IN6_IS_ADDR_LINKLOCAL(const in6_addr_emulation* a)
+{
+  return ((a->s6_addr[0] == 0xfe) && ((a->s6_addr[1] & 0xc0) == 0x80));
+}
+
+inline int IN6_IS_ADDR_SITELOCAL(const in6_addr_emulation* a)
+{
+  return ((a->s6_addr[0] == 0xfe) && ((a->s6_addr[1] & 0xc0) == 0xc0));
+}
+
+inline int IN6_IS_ADDR_V4MAPPED(const in6_addr_emulation* a)
+{
+  return ((a->s6_addr[0] == 0)
+      && (a->s6_addr[1] == 0)
+      && (a->s6_addr[2] == 0)
+      && (a->s6_addr[3] == 0)
+      && (a->s6_addr[4] == 0)
+      && (a->s6_addr[5] == 0)
+      && (a->s6_addr[6] == 0)
+      && (a->s6_addr[7] == 0)
+      && (a->s6_addr[8] == 0)
+      && (a->s6_addr[9] == 0)
+      && (a->s6_addr[10] == 0xff)
+      && (a->s6_addr[11] == 0xff));
+}
+
+inline int IN6_IS_ADDR_V4COMPAT(const in6_addr_emulation* a)
+{
+  return ((a->s6_addr[0] == 0)
+      && (a->s6_addr[1] == 0)
+      && (a->s6_addr[2] == 0)
+      && (a->s6_addr[3] == 0)
+      && (a->s6_addr[4] == 0)
+      && (a->s6_addr[5] == 0)
+      && (a->s6_addr[6] == 0)
+      && (a->s6_addr[7] == 0)
+      && (a->s6_addr[8] == 0)
+      && (a->s6_addr[9] == 0)
+      && (a->s6_addr[10] == 0xff)
+      && (a->s6_addr[11] == 0xff)
+      && !((a->s6_addr[12] == 0)
+        && (a->s6_addr[13] == 0)
+        && (a->s6_addr[14] == 0)
+        && ((a->s6_addr[15] == 0) || (a->s6_addr[15] == 1))));
+}
+
+inline int IN6_IS_ADDR_MC_NODELOCAL(const in6_addr_emulation* a)
+{
+  return IN6_IS_ADDR_MULTICAST(a) && ((a->s6_addr[1] & 0xf) == 1);
+}
+
+inline int IN6_IS_ADDR_MC_LINKLOCAL(const in6_addr_emulation* a)
+{
+  return IN6_IS_ADDR_MULTICAST(a) && ((a->s6_addr[1] & 0xf) == 2);
+}
+
+inline int IN6_IS_ADDR_MC_SITELOCAL(const in6_addr_emulation* a)
+{
+  return IN6_IS_ADDR_MULTICAST(a) && ((a->s6_addr[1] & 0xf) == 5);
+}
+
+inline int IN6_IS_ADDR_MC_ORGLOCAL(const in6_addr_emulation* a)
+{
+  return IN6_IS_ADDR_MULTICAST(a) && ((a->s6_addr[1] & 0xf) == 8);
+}
+
+inline int IN6_IS_ADDR_MC_GLOBAL(const in6_addr_emulation* a)
+{
+  return IN6_IS_ADDR_MULTICAST(a) && ((a->s6_addr[1] & 0xf) == 0xe);
+}
+
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // defined(BOOST_ASIO_HAS_OLD_WIN_SDK)
 
 // Even newer Platform SDKs that support IPv6 may not define IPV6_V6ONLY.
 #if !defined(IPV6_V6ONLY)
 # define IPV6_V6ONLY 27
 #endif
 
 // 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 // 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..d508e9d 100644
--- a/3rdParty/Boost/src/boost/asio/detail/op_queue.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/op_queue.hpp
@@ -1,40 +1,40 @@
 //
 // detail/op_queue.hpp
 // ~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_OP_QUEUE_HPP
 #define BOOST_ASIO_DETAIL_OP_QUEUE_HPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/noncopyable.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 template <typename Operation>
 class op_queue;
 
 class op_queue_access
 {
 public:
   template <typename Operation>
   static Operation* next(Operation* o)
   {
     return static_cast<Operation*>(o->next_);
   }
 
   template <typename Operation1, typename Operation2>
   static void next(Operation1*& o1, Operation2* o2)
   {
diff --git a/3rdParty/Boost/src/boost/asio/detail/operation.hpp b/3rdParty/Boost/src/boost/asio/detail/operation.hpp
index 99371a9..d2015e7 100644
--- a/3rdParty/Boost/src/boost/asio/detail/operation.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/operation.hpp
@@ -1,40 +1,40 @@
 //
 // detail/operation.hpp
 // ~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_OPERATION_HPP
 #define BOOST_ASIO_DETAIL_OPERATION_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/win_iocp_operation.hpp>
 #else
 # include <boost/asio/detail/task_io_service_operation.hpp>
 #endif
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 #if defined(BOOST_ASIO_HAS_IOCP)
 typedef win_iocp_operation operation;
 #else
 typedef task_io_service_operation operation;
 #endif
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #endif // 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..ad32736 100644
--- a/3rdParty/Boost/src/boost/asio/detail/pipe_select_interrupter.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/pipe_select_interrupter.hpp
@@ -1,89 +1,80 @@
 //
 // detail/pipe_select_interrupter.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_PIPE_SELECT_INTERRUPTER_HPP
 #define BOOST_ASIO_DETAIL_PIPE_SELECT_INTERRUPTER_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_WINDOWS)
 #if !defined(__CYGWIN__)
 #if !defined(__SYMBIAN32__)
 #if !defined(BOOST_ASIO_HAS_EVENTFD)
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 class pipe_select_interrupter
 {
 public:
   // Constructor.
   BOOST_ASIO_DECL pipe_select_interrupter();
 
   // Destructor.
   BOOST_ASIO_DECL ~pipe_select_interrupter();
 
-  // Recreate the interrupter's descriptors. Used after a fork.
-  BOOST_ASIO_DECL void recreate();
-
   // Interrupt the select call.
   BOOST_ASIO_DECL void interrupt();
 
   // Reset the select interrupt. Returns true if the call was interrupted.
   BOOST_ASIO_DECL bool reset();
 
   // Get the read descriptor to be passed to select.
   int read_descriptor() const
   {
     return read_descriptor_;
   }
 
 private:
-  // Open the descriptors. Throws on error.
-  BOOST_ASIO_DECL void open_descriptors();
-
-  // Close the descriptors.
-  BOOST_ASIO_DECL void close_descriptors();
-
   // The read end of a connection used to interrupt the select call. This file
   // descriptor is passed to select such that when it is time to stop, a single
   // byte will be written on the other end of the connection and this
   // descriptor will become readable.
   int read_descriptor_;
 
   // The write end of a connection used to interrupt the select call. A single
   // byte may be written to this to wake up the select which is waiting for the
   // other end to become readable.
   int write_descriptor_;
 };
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #if defined(BOOST_ASIO_HEADER_ONLY)
 # 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 // 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..75afc2b 100644
--- a/3rdParty/Boost/src/boost/asio/detail/pop_options.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/pop_options.hpp
@@ -1,40 +1,40 @@
 //
 // detail/pop_options.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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)
 //
 
 // No header guard
 
 #if defined(__COMO__)
 
 // Comeau C++
 
 #elif defined(__DMC__)
 
 // Digital Mars C++
 
 #elif defined(__INTEL_COMPILER) || defined(__ICL) \
   || defined(__ICC) || defined(__ECC)
 
 // Intel C++
 
 #elif defined(__GNUC__)
 
 // GNU C++
 
 # if defined(__MINGW32__) || defined(__CYGWIN__)
 #  pragma pack (pop)
 # endif
 
 # if defined(__OBJC__)
 #  if !defined(__APPLE_CC__) || (__APPLE_CC__ <= 1)
 #   if defined(BOOST_ASIO_OBJC_WORKAROUND)
 #    undef Protocol
 #    undef id
 #    undef BOOST_ASIO_OBJC_WORKAROUND
 #   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..dc2ed31 100644
--- a/3rdParty/Boost/src/boost/asio/detail/posix_event.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/posix_event.hpp
@@ -1,40 +1,40 @@
 //
 // detail/posix_event.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_POSIX_EVENT_HPP
 #define BOOST_ASIO_DETAIL_POSIX_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_HAS_PTHREADS) && !defined(BOOST_ASIO_DISABLE_THREADS)
 
 #include <boost/assert.hpp>
 #include <pthread.h>
 #include <boost/asio/detail/noncopyable.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 class posix_event
   : private noncopyable
 {
 public:
   // Constructor.
   BOOST_ASIO_DECL posix_event();
 
   // Destructor.
   ~posix_event()
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..b8be596 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,83 +1,76 @@
 //
 // detail/posix_fd_set_adapter.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_POSIX_FD_SET_ADAPTER_HPP
 #define BOOST_ASIO_DETAIL_POSIX_FD_SET_ADAPTER_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_WINDOWS) && !defined(__CYGWIN__)
 
 #include <cstring>
-#include <boost/asio/detail/noncopyable.hpp>
 #include <boost/asio/detail/socket_types.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 // Adapts the FD_SET type to meet the Descriptor_Set concept's requirements.
-class posix_fd_set_adapter : noncopyable
+class posix_fd_set_adapter
 {
 public:
   posix_fd_set_adapter()
     : max_descriptor_(invalid_socket)
   {
     using namespace std; // Needed for memset on Solaris.
     FD_ZERO(&fd_set_);
   }
 
-  void reset()
-  {
-    using namespace std; // Needed for memset on Solaris.
-    FD_ZERO(&fd_set_);
-  }
-
   bool set(socket_type descriptor)
   {
     if (descriptor < (socket_type)FD_SETSIZE)
     {
       if (max_descriptor_ == invalid_socket || descriptor > max_descriptor_)
         max_descriptor_ = descriptor;
       FD_SET(descriptor, &fd_set_);
       return true;
     }
     return false;
   }
 
   bool is_set(socket_type descriptor) const
   {
     return FD_ISSET(descriptor, &fd_set_) != 0;
   }
 
   operator fd_set*()
   {
     return &fd_set_;
   }
 
   socket_type max_descriptor() const
   {
     return max_descriptor_;
   }
 
 private:
   mutable fd_set fd_set_;
   socket_type max_descriptor_;
 };
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
diff --git a/3rdParty/Boost/src/boost/asio/detail/posix_mutex.hpp b/3rdParty/Boost/src/boost/asio/detail/posix_mutex.hpp
index a456c2a..5f5fd83 100644
--- a/3rdParty/Boost/src/boost/asio/detail/posix_mutex.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/posix_mutex.hpp
@@ -1,40 +1,40 @@
 //
 // detail/posix_mutex.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_POSIX_MUTEX_HPP
 #define BOOST_ASIO_DETAIL_POSIX_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_HAS_PTHREADS) && !defined(BOOST_ASIO_DISABLE_THREADS)
 
 #include <pthread.h>
 #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 posix_event;
 
 class posix_mutex
   : private noncopyable
 {
 public:
   typedef boost::asio::detail::scoped_lock<posix_mutex> scoped_lock;
 
   // Constructor.
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..88fa330 100644
--- a/3rdParty/Boost/src/boost/asio/detail/posix_signal_blocker.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/posix_signal_blocker.hpp
@@ -1,40 +1,40 @@
 //
 // detail/posix_signal_blocker.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_POSIX_SIGNAL_BLOCKER_HPP
 #define BOOST_ASIO_DETAIL_POSIX_SIGNAL_BLOCKER_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_HAS_PTHREADS) && !defined(BOOST_ASIO_DISABLE_THREADS)
 
 #include <csignal>
 #include <pthread.h>
 #include <signal.h>
 #include <boost/asio/detail/noncopyable.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 class posix_signal_blocker
   : private noncopyable
 {
 public:
   // Constructor blocks all signals for the calling thread.
   posix_signal_blocker()
     : blocked_(false)
   {
diff --git a/3rdParty/Boost/src/boost/asio/detail/posix_static_mutex.hpp b/3rdParty/Boost/src/boost/asio/detail/posix_static_mutex.hpp
deleted file mode 100644
index a27d9d8..0000000
--- a/3rdParty/Boost/src/boost/asio/detail/posix_static_mutex.hpp
+++ /dev/null
@@ -1,66 +0,0 @@
-//
-// detail/posix_static_mutex.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_POSIX_STATIC_MUTEX_HPP
-#define BOOST_ASIO_DETAIL_POSIX_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_HAS_PTHREADS) && !defined(BOOST_ASIO_DISABLE_THREADS)
-
-#include <pthread.h>
-#include <boost/asio/detail/scoped_lock.hpp>
-
-#include <boost/asio/detail/push_options.hpp>
-
-namespace boost {
-namespace asio {
-namespace detail {
-
-struct posix_static_mutex
-{
-  typedef boost::asio::detail::scoped_lock<posix_static_mutex> scoped_lock;
-
-  // Initialise the mutex.
-  void init()
-  {
-    // Nothing to do.
-  }
-
-  // Lock the mutex.
-  void lock()
-  {
-    (void)::pthread_mutex_lock(&mutex_); // Ignore EINVAL.
-  }
-
-  // Unlock the mutex.
-  void unlock()
-  {
-    (void)::pthread_mutex_unlock(&mutex_); // Ignore EINVAL.
-  }
-
-  ::pthread_mutex_t mutex_;
-};
-
-#define BOOST_ASIO_POSIX_STATIC_MUTEX_INIT { PTHREAD_MUTEX_INITIALIZER }
-
-} // namespace detail
-} // namespace asio
-} // namespace boost
-
-#include <boost/asio/detail/pop_options.hpp>
-
-#endif // defined(BOOST_HAS_PTHREADS) && !defined(BOOST_ASIO_DISABLE_THREADS)
-
-#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..5d8b684 100644
--- a/3rdParty/Boost/src/boost/asio/detail/posix_thread.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/posix_thread.hpp
@@ -1,77 +1,77 @@
 //
 // detail/posix_thread.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_POSIX_THREAD_HPP
 #define BOOST_ASIO_DETAIL_POSIX_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_HAS_PTHREADS) && !defined(BOOST_ASIO_DISABLE_THREADS)
 
 #include <pthread.h>
 #include <boost/asio/detail/noncopyable.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 extern "C"
 {
   BOOST_ASIO_DECL void* boost_asio_detail_posix_thread_function(void* arg);
 }
 
 class posix_thread
   : private noncopyable
 {
 public:
   // Constructor.
   template <typename Function>
-  posix_thread(Function f, unsigned int = 0)
+  posix_thread(Function f)
     : joined_(false)
   {
     start_thread(new func<Function>(f));
   }
 
   // Destructor.
   BOOST_ASIO_DECL ~posix_thread();
 
   // Wait for the thread to exit.
   BOOST_ASIO_DECL void join();
 
 private:
   friend void* boost_asio_detail_posix_thread_function(void* arg);
 
   class func_base
   {
   public:
     virtual ~func_base() {}
     virtual void run() = 0;
   };
 
   struct auto_func_base_ptr
   {
     func_base* ptr;
     ~auto_func_base_ptr() { delete ptr; }
   };
 
   template <typename Function>
   class func
     : public func_base
   {
   public:
     func(Function f)
       : f_(f)
     {
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..2edcbc1 100644
--- a/3rdParty/Boost/src/boost/asio/detail/posix_tss_ptr.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/posix_tss_ptr.hpp
@@ -1,40 +1,40 @@
 //
 // detail/posix_tss_ptr.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_POSIX_TSS_PTR_HPP
 #define BOOST_ASIO_DETAIL_POSIX_TSS_PTR_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_HAS_PTHREADS) && !defined(BOOST_ASIO_DISABLE_THREADS)
 
 #include <pthread.h>
 #include <boost/asio/detail/noncopyable.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 // Helper function to create thread-specific storage.
 BOOST_ASIO_DECL void posix_tss_ptr_create(pthread_key_t& key);
 
 template <typename T>
 class posix_tss_ptr
   : private noncopyable
 {
 public:
   // Constructor.
   posix_tss_ptr()
diff --git a/3rdParty/Boost/src/boost/asio/detail/push_options.hpp b/3rdParty/Boost/src/boost/asio/detail/push_options.hpp
index fef517d..050549d 100644
--- a/3rdParty/Boost/src/boost/asio/detail/push_options.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/push_options.hpp
@@ -1,40 +1,40 @@
 //
 // detail/push_options.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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)
 //
 
 // No header guard
 
 #if defined(__COMO__)
 
 // Comeau C++
 
 #elif defined(__DMC__)
 
 // Digital Mars C++
 
 #elif defined(__INTEL_COMPILER) || defined(__ICL) \
   || defined(__ICC) || defined(__ECC)
 
 // Intel C++
 
 #elif defined(__GNUC__)
 
 // GNU C++
 
 # if defined(__MINGW32__) || defined(__CYGWIN__)
 #  pragma pack (push, 8)
 # endif
 
 # if defined(__OBJC__)
 #  if !defined(__APPLE_CC__) || (__APPLE_CC__ <= 1)
 #   if !defined(BOOST_ASIO_DISABLE_OBJC_WORKAROUND)
 #    if !defined(Protocol) && !defined(id)
 #     define Protocol cpp_Protocol
 #     define id cpp_id
 #     define BOOST_ASIO_OBJC_WORKAROUND
@@ -68,60 +68,59 @@
 # pragma nopackwarning
 # if !defined(__MT__)
 #  error Multithreaded RTL must be selected.
 # endif // !defined(__MT__)
 
 #elif defined(__MWERKS__)
 
 // Metrowerks CodeWarrior
 
 #elif defined(__SUNPRO_CC)
 
 // Sun Workshop Compiler C++
 
 #elif defined(__HP_aCC)
 
 // HP aCC
 
 #elif defined(__MRC__) || defined(__SC__)
 
 // MPW MrCpp or SCpp
 
 #elif defined(__IBMCPP__)
 
 // IBM Visual Age
 
 #elif defined(_MSC_VER)
 
 // Microsoft Visual C++
 //
 // Must remain the last #elif since some other vendors (Metrowerks, for example)
 // also #define _MSC_VER
 
 # 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:4512)
 # 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)
 # endif // defined(_M_IX86) && defined(_Wp64)
 # pragma pack (push, 8)
 // Note that if the /Og optimisation flag is enabled with MSVC6, the compiler
 // has a tendency to incorrectly optimise away some calls to member template
 // functions, even though those functions contain code that should not be
 // optimised away! Therefore we will always disable this optimisation option
 // for the MSVC6 compiler.
 # if (_MSC_VER < 1300)
 #  pragma optimize ("g", off)
 # endif
 # if !defined(_MT)
 #  error Multithreaded RTL must be selected.
 # endif // !defined(_MT)
 
 #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..510c505 100644
--- a/3rdParty/Boost/src/boost/asio/detail/reactive_descriptor_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/reactive_descriptor_service.hpp
@@ -1,308 +1,255 @@
 //
 // detail/reactive_descriptor_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_REACTIVE_DESCRIPTOR_SERVICE_HPP
 #define BOOST_ASIO_DETAIL_REACTIVE_DESCRIPTOR_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_WINDOWS) && !defined(__CYGWIN__)
 
 #include <boost/utility/addressof.hpp>
 #include <boost/asio/buffer.hpp>
 #include <boost/asio/io_service.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>
 #include <boost/asio/detail/noncopyable.hpp>
 #include <boost/asio/detail/reactive_null_buffers_op.hpp>
 #include <boost/asio/detail/reactor.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 class reactive_descriptor_service
 {
 public:
   // The native type of a descriptor.
-  typedef int native_handle_type;
+  typedef int native_type;
 
   // The implementation type of the descriptor.
   class implementation_type
     : private boost::asio::detail::noncopyable
   {
   public:
     // Default constructor.
     implementation_type()
       : descriptor_(-1),
         state_(0)
     {
     }
 
   private:
     // Only this service will have access to the internal values.
     friend class reactive_descriptor_service;
 
     // The native descriptor representation.
     int descriptor_;
 
     // The current state of the descriptor.
     descriptor_ops::state_type state_;
 
     // Per-descriptor data used by the reactor.
     reactor::per_descriptor_data reactor_data_;
   };
 
   // Constructor.
   BOOST_ASIO_DECL reactive_descriptor_service(
       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 descriptor implementation.
   BOOST_ASIO_DECL void construct(implementation_type& impl);
 
-  // Move-construct a new descriptor implementation.
-  BOOST_ASIO_DECL void move_construct(implementation_type& impl,
-      implementation_type& other_impl);
-
-  // Move-assign from another descriptor implementation.
-  BOOST_ASIO_DECL void move_assign(implementation_type& impl,
-      reactive_descriptor_service& other_service,
-      implementation_type& other_impl);
-
   // Destroy a descriptor implementation.
   BOOST_ASIO_DECL void destroy(implementation_type& impl);
 
   // Assign a native descriptor to a descriptor implementation.
   BOOST_ASIO_DECL boost::system::error_code assign(implementation_type& impl,
-      const native_handle_type& native_descriptor,
-      boost::system::error_code& ec);
+      const native_type& native_descriptor, boost::system::error_code& ec);
 
   // Determine whether the descriptor is open.
   bool is_open(const implementation_type& impl) const
   {
     return impl.descriptor_ != -1;
   }
 
   // Destroy a descriptor implementation.
   BOOST_ASIO_DECL boost::system::error_code close(implementation_type& impl,
       boost::system::error_code& ec);
 
   // Get the native descriptor representation.
-  native_handle_type native_handle(const implementation_type& impl) const
+  native_type native(const implementation_type& impl) const
   {
     return impl.descriptor_;
   }
 
-  // Release ownership of the native descriptor representation.
-  BOOST_ASIO_DECL native_handle_type release(implementation_type& impl);
-
   // Cancel all operations associated with the descriptor.
   BOOST_ASIO_DECL boost::system::error_code cancel(implementation_type& impl,
       boost::system::error_code& ec);
 
   // Perform an IO control command on the descriptor.
   template <typename IO_Control_Command>
   boost::system::error_code io_control(implementation_type& impl,
       IO_Control_Command& command, boost::system::error_code& ec)
   {
     descriptor_ops::ioctl(impl.descriptor_, impl.state_,
         command.name(), static_cast<ioctl_arg_type*>(command.data()), ec);
     return ec;
   }
 
-  // Gets the non-blocking mode of the descriptor.
-  bool non_blocking(const implementation_type& impl) const
-  {
-    return (impl.state_ & descriptor_ops::user_set_non_blocking) != 0;
-  }
-
-  // Sets the non-blocking mode of the descriptor.
-  boost::system::error_code non_blocking(implementation_type& impl,
-      bool mode, boost::system::error_code& ec)
-  {
-    descriptor_ops::set_user_non_blocking(
-        impl.descriptor_, impl.state_, mode, ec);
-    return ec;
-  }
-
-  // Gets the non-blocking mode of the native descriptor implementation.
-  bool native_non_blocking(const implementation_type& impl) const
-  {
-    return (impl.state_ & descriptor_ops::internal_non_blocking) != 0;
-  }
-
-  // Sets the non-blocking mode of the native descriptor implementation.
-  boost::system::error_code native_non_blocking(implementation_type& impl,
-      bool mode, boost::system::error_code& ec)
-  {
-    descriptor_ops::set_internal_non_blocking(
-        impl.descriptor_, impl.state_, mode, ec);
-    return ec;
-  }
-
   // Write some data to the descriptor.
   template <typename ConstBufferSequence>
   size_t write_some(implementation_type& impl,
       const ConstBufferSequence& buffers, boost::system::error_code& ec)
   {
     buffer_sequence_adapter<boost::asio::const_buffer,
         ConstBufferSequence> bufs(buffers);
 
     return descriptor_ops::sync_write(impl.descriptor_, impl.state_,
         bufs.buffers(), bufs.count(), bufs.all_empty(), ec);
   }
 
   // Wait until data can be written without blocking.
   size_t write_some(implementation_type& impl,
       const null_buffers&, boost::system::error_code& ec)
   {
     // Wait for descriptor to become ready.
-    descriptor_ops::poll_write(impl.descriptor_, impl.state_, ec);
+    descriptor_ops::poll_write(impl.descriptor_, ec);
 
     return 0;
   }
 
   // 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)
   {
     // Allocate and construct an operation to wrap the handler.
     typedef descriptor_write_op<ConstBufferSequence, Handler> op;
     typename op::ptr p = { boost::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,
         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)
   {
     // Allocate and construct an operation to wrap the handler.
     typedef reactive_null_buffers_op<Handler> op;
     typename op::ptr p = { boost::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);
     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,
       const MutableBufferSequence& buffers, boost::system::error_code& ec)
   {
     buffer_sequence_adapter<boost::asio::mutable_buffer,
         MutableBufferSequence> bufs(buffers);
 
     return descriptor_ops::sync_read(impl.descriptor_, impl.state_,
         bufs.buffers(), bufs.count(), bufs.all_empty(), ec);
   }
 
   // Wait until data can be read without blocking.
   size_t read_some(implementation_type& impl,
       const null_buffers&, boost::system::error_code& ec)
   {
     // Wait for descriptor to become ready.
-    descriptor_ops::poll_read(impl.descriptor_, impl.state_, ec);
+    descriptor_ops::poll_read(impl.descriptor_, ec);
 
     return 0;
   }
 
   // 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)
   {
     // Allocate and construct an operation to wrap the handler.
     typedef descriptor_read_op<MutableBufferSequence, Handler> op;
     typename op::ptr p = { boost::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,
         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)
   {
     // Allocate and construct an operation to wrap the handler.
     typedef reactive_null_buffers_op<Handler> op;
     typename op::ptr p = { boost::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);
     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 non_blocking, bool noop);
 
   // The selector that performs event demultiplexing for the service.
   reactor& reactor_;
 };
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #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 // 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..6ccc19e 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,90 +1,85 @@
 //
 // detail/reactive_null_buffers_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_REACTIVE_NULL_BUFFERS_OP_HPP
 #define BOOST_ASIO_DETAIL_REACTIVE_NULL_BUFFERS_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/utility/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>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 template <typename Handler>
 class reactive_null_buffers_op : public reactor_op
 {
 public:
   BOOST_ASIO_DEFINE_HANDLER_PTR(reactive_null_buffers_op);
 
-  reactive_null_buffers_op(Handler& handler)
+  reactive_null_buffers_op(Handler handler)
     : reactor_op(&reactive_null_buffers_op::do_perform,
         &reactive_null_buffers_op::do_complete),
-      handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler))
+      handler_(handler)
   {
   }
 
   static bool do_perform(reactor_op*)
   {
     return true;
   }
 
   static void do_complete(io_service_impl* owner, operation* base,
-      const boost::system::error_code& /*ec*/,
-      std::size_t /*bytes_transferred*/)
+      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 };
 
-    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.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::detail::fenced_block b;
       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 // BOOST_ASIO_DETAIL_REACTIVE_NULL_BUFFERS_OP_HPP
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..303c1f0 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,180 +1,163 @@
 //
 // detail/reactive_serial_port_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2011 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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_REACTIVE_SERIAL_PORT_SERVICE_HPP
 #define BOOST_ASIO_DETAIL_REACTIVE_SERIAL_PORT_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_HAS_SERIAL_PORT)
 #if !defined(BOOST_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>
 #include <boost/asio/detail/reactive_descriptor_service.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 // Extend reactive_descriptor_service to provide serial port support.
 class reactive_serial_port_service
 {
 public:
   // The native type of a serial port.
-  typedef reactive_descriptor_service::native_handle_type native_handle_type;
+  typedef reactive_descriptor_service::native_type native_type;
 
   // The implementation type of the serial port.
   typedef reactive_descriptor_service::implementation_type implementation_type;
 
   BOOST_ASIO_DECL reactive_serial_port_service(
       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 serial port implementation.
   void construct(implementation_type& impl)
   {
     descriptor_service_.construct(impl);
   }
 
-  // Move-construct a new serial port implementation.
-  void move_construct(implementation_type& impl,
-      implementation_type& other_impl)
-  {
-    descriptor_service_.move_construct(impl, other_impl);
-  }
-
-  // Move-assign from another serial port implementation.
-  void move_assign(implementation_type& impl,
-      reactive_serial_port_service& other_service,
-      implementation_type& other_impl)
-  {
-    descriptor_service_.move_assign(impl,
-        other_service.descriptor_service_, other_impl);
-  }
-
   // Destroy a serial port implementation.
   void destroy(implementation_type& impl)
   {
     descriptor_service_.destroy(impl);
   }
 
   // Open the serial port using the specified device name.
   BOOST_ASIO_DECL boost::system::error_code open(implementation_type& impl,
       const std::string& device, boost::system::error_code& ec);
 
   // Assign a native descriptor to a serial port implementation.
   boost::system::error_code assign(implementation_type& impl,
-      const native_handle_type& native_descriptor,
-      boost::system::error_code& ec)
+      const native_type& native_descriptor, boost::system::error_code& ec)
   {
     return descriptor_service_.assign(impl, native_descriptor, ec);
   }
 
   // Determine whether the serial port is open.
   bool is_open(const implementation_type& impl) const
   {
     return descriptor_service_.is_open(impl);
   }
 
   // Destroy a serial port implementation.
   boost::system::error_code close(implementation_type& impl,
       boost::system::error_code& ec)
   {
     return descriptor_service_.close(impl, ec);
   }
 
   // Get the native serial port representation.
-  native_handle_type native_handle(implementation_type& impl)
+  native_type native(implementation_type& impl)
   {
-    return descriptor_service_.native_handle(impl);
+    return descriptor_service_.native(impl);
   }
 
   // Cancel all operations associated with the serial port.
   boost::system::error_code cancel(implementation_type& impl,
       boost::system::error_code& ec)
   {
     return descriptor_service_.cancel(impl, ec);
   }
 
   // Set an option on the serial port.
   template <typename SettableSerialPortOption>
   boost::system::error_code set_option(implementation_type& impl,
       const SettableSerialPortOption& option, boost::system::error_code& ec)
   {
     return do_set_option(impl,
         &reactive_serial_port_service::store_option<SettableSerialPortOption>,
         &option, ec);
   }
 
   // Get an option from the serial port.
   template <typename GettableSerialPortOption>
   boost::system::error_code get_option(const implementation_type& impl,
       GettableSerialPortOption& option, boost::system::error_code& ec) const
   {
     return do_get_option(impl,
         &reactive_serial_port_service::load_option<GettableSerialPortOption>,
         &option, ec);
   }
 
   // Send a break sequence to the serial port.
   boost::system::error_code send_break(implementation_type& impl,
       boost::system::error_code& ec)
   {
     errno = 0;
     descriptor_ops::error_wrapper(::tcsendbreak(
-          descriptor_service_.native_handle(impl), 0), ec);
+          descriptor_service_.native(impl), 0), ec);
     return ec;
   }
 
   // Write the given data. Returns the number of bytes sent.
   template <typename ConstBufferSequence>
   size_t write_some(implementation_type& impl,
       const ConstBufferSequence& buffers, boost::system::error_code& ec)
   {
     return descriptor_service_.write_some(impl, buffers, ec);
   }
 
   // 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)
   {
     descriptor_service_.async_write_some(impl, buffers, handler);
   }
 
   // Read some data. Returns the number of bytes received.
   template <typename MutableBufferSequence>
   size_t read_some(implementation_type& impl,
       const MutableBufferSequence& buffers, boost::system::error_code& ec)
   {
     return descriptor_service_.read_some(impl, buffers, ec);
   }
 
   // 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)
   {
     descriptor_service_.async_read_some(impl, buffers, handler);
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..3805c9f 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,40 +1,40 @@
 //
 // detail/reactive_socket_accept_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_REACTIVE_SOCKET_ACCEPT_OP_HPP
 #define BOOST_ASIO_DETAIL_REACTIVE_SOCKET_ACCEPT_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/utility/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>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 template <typename Socket, typename Protocol>
 class reactive_socket_accept_op_base : public reactor_op
 {
 public:
   reactive_socket_accept_op_base(socket_type socket,
       socket_ops::state_type state, Socket& peer, const Protocol& protocol,
       typename Protocol::endpoint* peer_endpoint, func_type complete_func)
     : reactor_op(&reactive_socket_accept_op_base::do_perform, complete_func),
@@ -55,84 +55,79 @@ 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)
     {
       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();
     }
 
     return result;
   }
 
 private:
   socket_type socket_;
   socket_ops::state_type state_;
   Socket& peer_;
   Protocol protocol_;
   typename Protocol::endpoint* peer_endpoint_;
 };
 
 template <typename Socket, typename Protocol, typename Handler>
 class reactive_socket_accept_op :
   public reactive_socket_accept_op_base<Socket, Protocol>
 {
 public:
   BOOST_ASIO_DEFINE_HANDLER_PTR(reactive_socket_accept_op);
 
   reactive_socket_accept_op(socket_type socket,
       socket_ops::state_type state, Socket& peer, const Protocol& protocol,
-      typename Protocol::endpoint* peer_endpoint, Handler& handler)
+      typename Protocol::endpoint* peer_endpoint, Handler handler)
     : reactive_socket_accept_op_base<Socket, Protocol>(socket, state, peer,
         protocol, peer_endpoint, &reactive_socket_accept_op::do_complete),
-      handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler))
+      handler_(handler)
   {
   }
 
   static void do_complete(io_service_impl* owner, operation* base,
-      const boost::system::error_code& /*ec*/,
-      std::size_t /*bytes_transferred*/)
+      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 };
 
-    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.reset();
 
     // Make the upcall if required.
     if (owner)
     {
-      fenced_block b(fenced_block::half);
-      BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_));
+      boost::asio::detail::fenced_block b;
       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 // BOOST_ASIO_DETAIL_REACTIVE_SOCKET_ACCEPT_OP_HPP
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..6de7474 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,108 +1,103 @@
 //
 // detail/reactive_socket_connect_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_REACTIVE_SOCKET_CONNECT_OP_HPP
 #define BOOST_ASIO_DETAIL_REACTIVE_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>
 #include <boost/utility/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/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 class reactive_socket_connect_op_base : public reactor_op
 {
 public:
   reactive_socket_connect_op_base(socket_type socket, func_type complete_func)
     : reactor_op(&reactive_socket_connect_op_base::do_perform, complete_func),
       socket_(socket)
   {
   }
 
   static bool do_perform(reactor_op* base)
   {
     reactive_socket_connect_op_base* o(
         static_cast<reactive_socket_connect_op_base*>(base));
 
     return socket_ops::non_blocking_connect(o->socket_, o->ec_);
   }
 
 private:
   socket_type socket_;
 };
 
 template <typename Handler>
 class reactive_socket_connect_op : public reactive_socket_connect_op_base
 {
 public:
   BOOST_ASIO_DEFINE_HANDLER_PTR(reactive_socket_connect_op);
 
-  reactive_socket_connect_op(socket_type socket, Handler& handler)
+  reactive_socket_connect_op(socket_type socket, Handler handler)
     : reactive_socket_connect_op_base(socket,
         &reactive_socket_connect_op::do_complete),
-      handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler))
+      handler_(handler)
   {
   }
 
   static void do_complete(io_service_impl* owner, operation* base,
-      const boost::system::error_code& /*ec*/,
-      std::size_t /*bytes_transferred*/)
+      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 };
 
-    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.reset();
 
     // Make the upcall if required.
     if (owner)
     {
-      fenced_block b(fenced_block::half);
-      BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_));
+      boost::asio::detail::fenced_block b;
       boost_asio_handler_invoke_helpers::invoke(handler, handler);
-      BOOST_ASIO_HANDLER_INVOCATION_END;
     }
   }
 
 private:
   Handler handler_;
 };
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // BOOST_ASIO_DETAIL_REACTIVE_SOCKET_CONNECT_OP_HPP
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..75ce44f 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,125 +1,120 @@
 //
 // detail/reactive_socket_recv_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_REACTIVE_SOCKET_RECV_OP_HPP
 #define BOOST_ASIO_DETAIL_REACTIVE_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>
 #include <boost/utility/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/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 template <typename MutableBufferSequence>
 class reactive_socket_recv_op_base : public reactor_op
 {
 public:
   reactive_socket_recv_op_base(socket_type socket,
       socket_ops::state_type state, const MutableBufferSequence& buffers,
       socket_base::message_flags flags, func_type complete_func)
     : reactor_op(&reactive_socket_recv_op_base::do_perform, complete_func),
       socket_(socket),
       state_(state),
       buffers_(buffers),
       flags_(flags)
   {
   }
 
   static bool do_perform(reactor_op* base)
   {
     reactive_socket_recv_op_base* o(
         static_cast<reactive_socket_recv_op_base*>(base));
 
     buffer_sequence_adapter<boost::asio::mutable_buffer,
         MutableBufferSequence> bufs(o->buffers_);
 
     return socket_ops::non_blocking_recv(o->socket_,
         bufs.buffers(), bufs.count(), o->flags_,
-        (o->state_ & socket_ops::stream_oriented) != 0,
+        (o->state_ & socket_ops::stream_oriented),
         o->ec_, o->bytes_transferred_);
   }
 
 private:
   socket_type socket_;
   socket_ops::state_type state_;
   MutableBufferSequence buffers_;
   socket_base::message_flags flags_;
 };
 
 template <typename MutableBufferSequence, typename Handler>
 class reactive_socket_recv_op :
   public reactive_socket_recv_op_base<MutableBufferSequence>
 {
 public:
   BOOST_ASIO_DEFINE_HANDLER_PTR(reactive_socket_recv_op);
 
   reactive_socket_recv_op(socket_type socket,
       socket_ops::state_type state, const MutableBufferSequence& buffers,
-      socket_base::message_flags flags, Handler& handler)
+      socket_base::message_flags flags, Handler handler)
     : reactive_socket_recv_op_base<MutableBufferSequence>(socket, state,
         buffers, flags, &reactive_socket_recv_op::do_complete),
-      handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler))
+      handler_(handler)
   {
   }
 
   static void do_complete(io_service_impl* owner, operation* base,
-      const boost::system::error_code& /*ec*/,
-      std::size_t /*bytes_transferred*/)
+      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 };
 
-    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.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::detail::fenced_block b;
       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 // BOOST_ASIO_DETAIL_REACTIVE_SOCKET_RECV_OP_HPP
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..b496ea0 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,40 +1,40 @@
 //
 // detail/reactive_socket_recvfrom_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_REACTIVE_SOCKET_RECVFROM_OP_HPP
 #define BOOST_ASIO_DETAIL_REACTIVE_SOCKET_RECVFROM_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/utility/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/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 template <typename MutableBufferSequence, typename Endpoint>
 class reactive_socket_recvfrom_op_base : public reactor_op
 {
 public:
   reactive_socket_recvfrom_op_base(socket_type socket, int protocol_type,
       const MutableBufferSequence& buffers, Endpoint& endpoint,
       socket_base::message_flags flags, func_type complete_func)
     : reactor_op(&reactive_socket_recvfrom_op_base::do_perform, complete_func),
       socket_(socket),
@@ -50,86 +50,81 @@ public:
     reactive_socket_recvfrom_op_base* o(
         static_cast<reactive_socket_recvfrom_op_base*>(base));
 
     buffer_sequence_adapter<boost::asio::mutable_buffer,
         MutableBufferSequence> bufs(o->buffers_);
 
     std::size_t addr_len = o->sender_endpoint_.capacity();
     bool result = socket_ops::non_blocking_recvfrom(o->socket_,
         bufs.buffers(), bufs.count(), o->flags_,
         o->sender_endpoint_.data(), &addr_len,
         o->ec_, o->bytes_transferred_);
 
     if (result && !o->ec_)
       o->sender_endpoint_.resize(addr_len);
 
     return result;
   }
 
 private:
   socket_type socket_;
   int protocol_type_;
   MutableBufferSequence buffers_;
   Endpoint& sender_endpoint_;
   socket_base::message_flags flags_;
 };
 
 template <typename MutableBufferSequence, typename Endpoint, typename Handler>
 class reactive_socket_recvfrom_op :
   public reactive_socket_recvfrom_op_base<MutableBufferSequence, Endpoint>
 {
 public:
   BOOST_ASIO_DEFINE_HANDLER_PTR(reactive_socket_recvfrom_op);
 
   reactive_socket_recvfrom_op(socket_type socket, int protocol_type,
       const MutableBufferSequence& buffers, Endpoint& endpoint,
-      socket_base::message_flags flags, Handler& handler)
+      socket_base::message_flags flags, Handler handler)
     : reactive_socket_recvfrom_op_base<MutableBufferSequence, Endpoint>(
         socket, protocol_type, buffers, endpoint, flags,
         &reactive_socket_recvfrom_op::do_complete),
-      handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler))
+      handler_(handler)
   {
   }
 
   static void do_complete(io_service_impl* owner, operation* base,
-      const boost::system::error_code& /*ec*/,
-      std::size_t /*bytes_transferred*/)
+      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 };
 
-    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.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::detail::fenced_block b;
       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 // BOOST_ASIO_DETAIL_REACTIVE_SOCKET_RECVFROM_OP_HPP
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
deleted file mode 100644
index e9c2483..0000000
--- a/3rdParty/Boost/src/boost/asio/detail/reactive_socket_recvmsg_op.hpp
+++ /dev/null
@@ -1,127 +0,0 @@
-//
-// detail/reactive_socket_recvmsg_op.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_REACTIVE_SOCKET_RECVMSG_OP_HPP
-#define BOOST_ASIO_DETAIL_REACTIVE_SOCKET_RECVMSG_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/utility/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>
-
-#include <boost/asio/detail/push_options.hpp>
-
-namespace boost {
-namespace asio {
-namespace detail {
-
-template <typename MutableBufferSequence>
-class reactive_socket_recvmsg_op_base : public reactor_op
-{
-public:
-  reactive_socket_recvmsg_op_base(socket_type socket,
-      const MutableBufferSequence& buffers, socket_base::message_flags in_flags,
-      socket_base::message_flags& out_flags, func_type complete_func)
-    : reactor_op(&reactive_socket_recvmsg_op_base::do_perform, complete_func),
-      socket_(socket),
-      buffers_(buffers),
-      in_flags_(in_flags),
-      out_flags_(out_flags)
-  {
-  }
-
-  static bool do_perform(reactor_op* base)
-  {
-    reactive_socket_recvmsg_op_base* o(
-        static_cast<reactive_socket_recvmsg_op_base*>(base));
-
-    buffer_sequence_adapter<boost::asio::mutable_buffer,
-        MutableBufferSequence> bufs(o->buffers_);
-
-    return socket_ops::non_blocking_recvmsg(o->socket_,
-        bufs.buffers(), bufs.count(),
-        o->in_flags_, o->out_flags_,
-        o->ec_, o->bytes_transferred_);
-  }
-
-private:
-  socket_type socket_;
-  MutableBufferSequence buffers_;
-  socket_base::message_flags in_flags_;
-  socket_base::message_flags& out_flags_;
-};
-
-template <typename MutableBufferSequence, typename Handler>
-class reactive_socket_recvmsg_op :
-  public reactive_socket_recvmsg_op_base<MutableBufferSequence>
-{
-public:
-  BOOST_ASIO_DEFINE_HANDLER_PTR(reactive_socket_recvmsg_op);
-
-  reactive_socket_recvmsg_op(socket_type socket,
-      const MutableBufferSequence& buffers, socket_base::message_flags in_flags,
-      socket_base::message_flags& out_flags, Handler& handler)
-    : reactive_socket_recvmsg_op_base<MutableBufferSequence>(socket, buffers,
-        in_flags, out_flags, &reactive_socket_recvmsg_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& /*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 };
-
-    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.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 // BOOST_ASIO_DETAIL_REACTIVE_SOCKET_RECVMSG_OP_HPP
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..2fe195e 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,122 +1,117 @@
 //
 // detail/reactive_socket_send_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_REACTIVE_SOCKET_SEND_OP_HPP
 #define BOOST_ASIO_DETAIL_REACTIVE_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>
 #include <boost/utility/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/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 template <typename ConstBufferSequence>
 class reactive_socket_send_op_base : public reactor_op
 {
 public:
   reactive_socket_send_op_base(socket_type socket,
       const ConstBufferSequence& buffers,
       socket_base::message_flags flags, func_type complete_func)
     : reactor_op(&reactive_socket_send_op_base::do_perform, complete_func),
       socket_(socket),
       buffers_(buffers),
       flags_(flags)
   {
   }
 
   static bool do_perform(reactor_op* base)
   {
     reactive_socket_send_op_base* o(
         static_cast<reactive_socket_send_op_base*>(base));
 
     buffer_sequence_adapter<boost::asio::const_buffer,
         ConstBufferSequence> bufs(o->buffers_);
 
     return socket_ops::non_blocking_send(o->socket_,
           bufs.buffers(), bufs.count(), o->flags_,
           o->ec_, o->bytes_transferred_);
   }
 
 private:
   socket_type socket_;
   ConstBufferSequence buffers_;
   socket_base::message_flags flags_;
 };
 
 template <typename ConstBufferSequence, typename Handler>
 class reactive_socket_send_op :
   public reactive_socket_send_op_base<ConstBufferSequence>
 {
 public:
   BOOST_ASIO_DEFINE_HANDLER_PTR(reactive_socket_send_op);
 
   reactive_socket_send_op(socket_type socket,
       const ConstBufferSequence& buffers,
-      socket_base::message_flags flags, Handler& handler)
+      socket_base::message_flags flags, Handler handler)
     : reactive_socket_send_op_base<ConstBufferSequence>(socket,
         buffers, flags, &reactive_socket_send_op::do_complete),
-      handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler))
+      handler_(handler)
   {
   }
 
   static void do_complete(io_service_impl* owner, operation* base,
-      const boost::system::error_code& /*ec*/,
-      std::size_t /*bytes_transferred*/)
+      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 };
 
-    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.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::detail::fenced_block b;
       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 // BOOST_ASIO_DETAIL_REACTIVE_SOCKET_SEND_OP_HPP
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..12046c3 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,40 +1,40 @@
 //
 // detail/reactive_socket_sendto_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_REACTIVE_SOCKET_SENDTO_OP_HPP
 #define BOOST_ASIO_DETAIL_REACTIVE_SOCKET_SENDTO_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/utility/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/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 template <typename ConstBufferSequence, typename Endpoint>
 class reactive_socket_sendto_op_base : public reactor_op
 {
 public:
   reactive_socket_sendto_op_base(socket_type socket,
       const ConstBufferSequence& buffers, const Endpoint& endpoint,
       socket_base::message_flags flags, func_type complete_func)
     : reactor_op(&reactive_socket_sendto_op_base::do_perform, complete_func),
       socket_(socket),
@@ -42,84 +42,79 @@ public:
       destination_(endpoint),
       flags_(flags)
   {
   }
 
   static bool do_perform(reactor_op* base)
   {
     reactive_socket_sendto_op_base* o(
         static_cast<reactive_socket_sendto_op_base*>(base));
 
     buffer_sequence_adapter<boost::asio::const_buffer,
         ConstBufferSequence> bufs(o->buffers_);
 
     return socket_ops::non_blocking_sendto(o->socket_,
           bufs.buffers(), bufs.count(), o->flags_,
           o->destination_.data(), o->destination_.size(),
           o->ec_, o->bytes_transferred_);
   }
 
 private:
   socket_type socket_;
   ConstBufferSequence buffers_;
   Endpoint destination_;
   socket_base::message_flags flags_;
 };
 
 template <typename ConstBufferSequence, typename Endpoint, typename Handler>
 class reactive_socket_sendto_op :
   public reactive_socket_sendto_op_base<ConstBufferSequence, Endpoint>
 {
 public:
   BOOST_ASIO_DEFINE_HANDLER_PTR(reactive_socket_sendto_op);
 
   reactive_socket_sendto_op(socket_type socket,
       const ConstBufferSequence& buffers, const Endpoint& endpoint,
-      socket_base::message_flags flags, Handler& handler)
+      socket_base::message_flags flags, Handler handler)
     : reactive_socket_sendto_op_base<ConstBufferSequence, Endpoint>(socket,
         buffers, endpoint, flags, &reactive_socket_sendto_op::do_complete),
-      handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler))
+      handler_(handler)
   {
   }
 
   static void do_complete(io_service_impl* owner, operation* base,
-      const boost::system::error_code& /*ec*/,
-      std::size_t /*bytes_transferred*/)
+      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 };
 
-    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.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::detail::fenced_block b;
       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 // BOOST_ASIO_DETAIL_REACTIVE_SOCKET_SENDTO_OP_HPP
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..92eef4a 100644
--- a/3rdParty/Boost/src/boost/asio/detail/reactive_socket_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/reactive_socket_service.hpp
@@ -1,158 +1,137 @@
 //
 // detail/reactive_socket_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_REACTIVE_SOCKET_SERVICE_HPP
 #define BOOST_ASIO_DETAIL_REACTIVE_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_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/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>
 #include <boost/asio/detail/reactive_socket_sendto_op.hpp>
 #include <boost/asio/detail/reactive_socket_service_base.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/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 template <typename Protocol>
 class reactive_socket_service :
   public reactive_socket_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 socket_type native_handle_type;
+  typedef socket_type native_type;
 
   // The implementation type of the socket.
   struct implementation_type :
     reactive_socket_service_base::base_implementation_type
   {
     // Default constructor.
     implementation_type()
       : protocol_(endpoint_type().protocol())
     {
     }
 
     // The protocol associated with the socket.
     protocol_type protocol_;
   };
 
   // Constructor.
   reactive_socket_service(boost::asio::io_service& io_service)
     : reactive_socket_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,
-      reactive_socket_service_base& 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();
-  }
-
   // 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))
       impl.protocol_ = protocol;
     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,
+      const protocol_type& protocol, const native_type& native_socket,
       boost::system::error_code& ec)
   {
     if (!do_assign(impl, protocol.type(), native_socket, ec))
       impl.protocol_ = protocol;
     return ec;
   }
 
   // Get the native socket representation.
-  native_handle_type native_handle(implementation_type& impl)
+  native_type native(implementation_type& impl)
   {
     return impl.socket_;
   }
 
   // Bind the socket to the specified local endpoint.
   boost::system::error_code bind(implementation_type& impl,
       const endpoint_type& endpoint, boost::system::error_code& ec)
   {
     socket_ops::bind(impl.socket_, endpoint.data(), endpoint.size(), ec);
     return ec;
   }
 
   // Set a socket option.
   template <typename Option>
   boost::system::error_code set_option(implementation_type& impl,
       const Option& option, boost::system::error_code& ec)
   {
     socket_ops::setsockopt(impl.socket_, impl.state_,
         option.level(impl.protocol_), option.name(impl.protocol_),
         option.data(impl.protocol_), option.size(impl.protocol_), ec);
     return ec;
   }
 
   // Set 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_);
     socket_ops::getsockopt(impl.socket_, impl.state_,
         option.level(impl.protocol_), option.name(impl.protocol_),
         option.data(impl.protocol_), &size, ec);
     if (!ec)
       option.resize(impl.protocol_, size);
     return ec;
@@ -172,257 +151,242 @@ public:
 
   // Get the remote endpoint.
   endpoint_type remote_endpoint(const implementation_type& impl,
       boost::system::error_code& ec) const
   {
     endpoint_type endpoint;
     std::size_t addr_len = endpoint.capacity();
     if (socket_ops::getpeername(impl.socket_,
           endpoint.data(), &addr_len, false, ec))
       return endpoint_type();
     endpoint.resize(addr_len);
     return endpoint;
   }
 
   // Send a datagram to the specified endpoint. Returns the number of bytes
   // sent.
   template <typename ConstBufferSequence>
   size_t send_to(implementation_type& impl, const ConstBufferSequence& buffers,
       const endpoint_type& destination, socket_base::message_flags flags,
       boost::system::error_code& ec)
   {
     buffer_sequence_adapter<boost::asio::const_buffer,
         ConstBufferSequence> bufs(buffers);
 
     return socket_ops::sync_sendto(impl.socket_, impl.state_,
         bufs.buffers(), bufs.count(), flags,
         destination.data(), destination.size(), ec);
   }
 
   // Wait until data can be sent without blocking.
   size_t send_to(implementation_type& impl, const null_buffers&,
       const endpoint_type&, socket_base::message_flags,
       boost::system::error_code& ec)
   {
     // Wait for socket to become ready.
-    socket_ops::poll_write(impl.socket_, impl.state_, ec);
+    socket_ops::poll_write(impl.socket_, ec);
 
     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& impl,
       const ConstBufferSequence& buffers,
       const endpoint_type& destination, socket_base::message_flags flags,
       Handler 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),
       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);
     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)
   {
     // Allocate and construct an operation to wrap the handler.
     typedef reactive_null_buffers_op<Handler> op;
     typename op::ptr p = { boost::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);
     p.v = p.p = 0;
   }
 
   // Receive a datagram with the endpoint of the sender. Returns the number of
   // bytes received.
   template <typename MutableBufferSequence>
   size_t receive_from(implementation_type& impl,
       const MutableBufferSequence& buffers,
       endpoint_type& sender_endpoint, socket_base::message_flags flags,
       boost::system::error_code& ec)
   {
     buffer_sequence_adapter<boost::asio::mutable_buffer,
         MutableBufferSequence> bufs(buffers);
 
     std::size_t addr_len = sender_endpoint.capacity();
     std::size_t bytes_recvd = socket_ops::sync_recvfrom(
         impl.socket_, impl.state_, bufs.buffers(), bufs.count(),
         flags, sender_endpoint.data(), &addr_len, ec);
 
     if (!ec)
       sender_endpoint.resize(addr_len);
 
     return bytes_recvd;
   }
 
   // Wait until data can be received without blocking.
   size_t receive_from(implementation_type& impl, const null_buffers&,
       endpoint_type& sender_endpoint, socket_base::message_flags,
       boost::system::error_code& ec)
   {
     // Wait for socket to become ready.
-    socket_ops::poll_read(impl.socket_, impl.state_, ec);
+    socket_ops::poll_read(impl.socket_, ec);
 
     // Reset endpoint since it can be given no sensible value at this time.
     sender_endpoint = endpoint_type();
 
     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& impl,
       const MutableBufferSequence& buffers, endpoint_type& sender_endpoint,
       socket_base::message_flags flags, Handler 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),
       boost_asio_handler_alloc_helpers::allocate(
         sizeof(op), handler), 0 };
-    int protocol = impl.protocol_.type();
-    p.p = new (p.v) op(impl.socket_, protocol,
+    int protocol_type = impl.protocol_.type();
+    p.p = new (p.v) op(impl.socket_, protocol_type,
         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.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)
   {
     // Allocate and construct an operation to wrap the handler.
     typedef reactive_null_buffers_op<Handler> op;
     typename op::ptr p = { boost::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)"));
-
     // 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.v = p.p = 0;
   }
 
   // Accept a new connection.
   template <typename Socket>
   boost::system::error_code accept(implementation_type& impl,
       Socket& peer, endpoint_type* peer_endpoint, boost::system::error_code& ec)
   {
     // We cannot accept a socket that is already open.
     if (peer.is_open())
     {
       ec = boost::asio::error::already_open;
       return ec;
     }
 
     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() != invalid_socket)
     {
       if (peer_endpoint)
         peer_endpoint->resize(addr_len);
       if (!peer.assign(impl.protocol_, new_socket.get(), ec))
         new_socket.release();
     }
 
     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& impl, Socket& peer,
       endpoint_type* peer_endpoint, Handler 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),
       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());
     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)
   {
     socket_ops::sync_connect(impl.socket_,
         peer_endpoint.data(), peer_endpoint.size(), ec);
     return ec;
   }
 
   // Start an asynchronous connect.
   template <typename Handler>
   void async_connect(implementation_type& impl,
       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),
       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());
     p.v = p.p = 0;
   }
 };
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // !defined(BOOST_ASIO_HAS_IOCP)
 
 #endif // BOOST_ASIO_DETAIL_REACTIVE_SOCKET_SERVICE_HPP
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..df87ddb 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,429 +1,300 @@
 //
 // detail/reactive_socket_service_base.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_REACTIVE_SOCKET_SERVICE_BASE_HPP
 #define BOOST_ASIO_DETAIL_REACTIVE_SOCKET_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_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/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>
 #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/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 class reactive_socket_service_base
 {
 public:
   // The native type of a socket.
-  typedef socket_type native_handle_type;
+  typedef socket_type native_type;
 
   // The implementation type of the socket.
   struct base_implementation_type
   {
     // The native socket representation.
     socket_type socket_;
 
     // The current state of the socket.
     socket_ops::state_type state_;
 
     // Per-descriptor data used by the reactor.
     reactor::per_descriptor_data reactor_data_;
   };
 
   // Constructor.
   BOOST_ASIO_DECL reactive_socket_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& impl);
 
-  // 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,
-      reactive_socket_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_ != invalid_socket;
   }
 
   // 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)
+  native_type native(base_implementation_type& impl)
   {
     return impl.socket_;
   }
 
   // Cancel all operations associated with the socket.
   BOOST_ASIO_DECL boost::system::error_code cancel(
       base_implementation_type& impl, boost::system::error_code& ec);
 
   // Determine whether the socket is at the out-of-band data mark.
   bool at_mark(const base_implementation_type& impl,
       boost::system::error_code& ec) const
   {
     return socket_ops::sockatmark(impl.socket_, ec);
   }
 
   // Determine the number of bytes available for reading.
   std::size_t available(const base_implementation_type& impl,
       boost::system::error_code& ec) const
   {
     return socket_ops::available(impl.socket_, ec);
   }
 
   // Place the socket into the state where it will listen for new connections.
   boost::system::error_code listen(base_implementation_type& impl,
       int backlog, boost::system::error_code& ec)
   {
     socket_ops::listen(impl.socket_, backlog, ec);
     return ec;
   }
 
   // Perform an IO control command on the socket.
   template <typename IO_Control_Command>
   boost::system::error_code io_control(base_implementation_type& impl,
       IO_Control_Command& command, boost::system::error_code& ec)
   {
     socket_ops::ioctl(impl.socket_, impl.state_, command.name(),
         static_cast<ioctl_arg_type*>(command.data()), ec);
     return ec;
   }
 
-  // Gets the non-blocking mode of the socket.
-  bool non_blocking(const base_implementation_type& impl) const
-  {
-    return (impl.state_ & socket_ops::user_set_non_blocking) != 0;
-  }
-
-  // Sets the non-blocking mode of the socket.
-  boost::system::error_code non_blocking(base_implementation_type& impl,
-      bool mode, boost::system::error_code& ec)
-  {
-    socket_ops::set_user_non_blocking(impl.socket_, impl.state_, mode, ec);
-    return ec;
-  }
-
-  // Gets the non-blocking mode of the native socket implementation.
-  bool native_non_blocking(const base_implementation_type& impl) const
-  {
-    return (impl.state_ & socket_ops::internal_non_blocking) != 0;
-  }
-
-  // Sets the non-blocking mode of the native socket implementation.
-  boost::system::error_code native_non_blocking(base_implementation_type& impl,
-      bool mode, boost::system::error_code& ec)
-  {
-    socket_ops::set_internal_non_blocking(impl.socket_, impl.state_, mode, ec);
-    return ec;
-  }
-
-  // Disable sends or receives on the socket.
+  /// Disable sends or receives on the socket.
   boost::system::error_code shutdown(base_implementation_type& impl,
       socket_base::shutdown_type what, boost::system::error_code& ec)
   {
     socket_ops::shutdown(impl.socket_, what, ec);
     return ec;
   }
 
   // Send the given data to the peer.
   template <typename ConstBufferSequence>
   size_t send(base_implementation_type& impl,
       const ConstBufferSequence& buffers,
       socket_base::message_flags flags, boost::system::error_code& ec)
   {
     buffer_sequence_adapter<boost::asio::const_buffer,
         ConstBufferSequence> bufs(buffers);
 
     return socket_ops::sync_send(impl.socket_, impl.state_,
         bufs.buffers(), bufs.count(), flags, bufs.all_empty(), ec);
   }
 
   // Wait until data can be sent without blocking.
   size_t send(base_implementation_type& impl, const null_buffers&,
       socket_base::message_flags, boost::system::error_code& ec)
   {
     // Wait for socket to become ready.
-    socket_ops::poll_write(impl.socket_, impl.state_, ec);
+    socket_ops::poll_write(impl.socket_, ec);
 
     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)
   {
     // Allocate and construct an operation to wrap the handler.
     typedef reactive_socket_send_op<ConstBufferSequence, Handler> op;
     typename op::ptr p = { boost::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,
         ((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)
   {
     // Allocate and construct an operation to wrap the handler.
     typedef reactive_null_buffers_op<Handler> op;
     typename op::ptr p = { boost::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);
     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,
       const MutableBufferSequence& buffers,
       socket_base::message_flags flags, boost::system::error_code& ec)
   {
     buffer_sequence_adapter<boost::asio::mutable_buffer,
         MutableBufferSequence> bufs(buffers);
 
     return socket_ops::sync_recv(impl.socket_, impl.state_,
         bufs.buffers(), bufs.count(), flags, bufs.all_empty(), ec);
   }
 
   // Wait until data can be received without blocking.
   size_t receive(base_implementation_type& impl, const null_buffers&,
       socket_base::message_flags, boost::system::error_code& ec)
   {
     // Wait for socket to become ready.
-    socket_ops::poll_read(impl.socket_, impl.state_, ec);
+    socket_ops::poll_read(impl.socket_, ec);
 
     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)
   {
     // Allocate and construct an operation to wrap the handler.
     typedef reactive_socket_recv_op<MutableBufferSequence, Handler> op;
     typename op::ptr p = { boost::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,
         ((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)
   {
     // Allocate and construct an operation to wrap the handler.
     typedef reactive_null_buffers_op<Handler> op;
     typename op::ptr p = { boost::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.v = p.p = 0;
   }
 
-  // Receive some data with associated flags. Returns the number of bytes
-  // received.
-  template <typename MutableBufferSequence>
-  size_t receive_with_flags(base_implementation_type& impl,
-      const MutableBufferSequence& buffers,
-      socket_base::message_flags in_flags,
-      socket_base::message_flags& out_flags, boost::system::error_code& ec)
-  {
-    buffer_sequence_adapter<boost::asio::mutable_buffer,
-        MutableBufferSequence> bufs(buffers);
-
-    return socket_ops::sync_recvmsg(impl.socket_, impl.state_,
-        bufs.buffers(), bufs.count(), in_flags, out_flags, ec);
-  }
-
-  // Wait until data can be received without blocking.
-  size_t receive_with_flags(base_implementation_type& impl,
-      const null_buffers&, socket_base::message_flags,
-      socket_base::message_flags& out_flags, boost::system::error_code& ec)
-  {
-    // Wait for socket to become ready.
-    socket_ops::poll_read(impl.socket_, impl.state_, ec);
-
-    // Clear out_flags, since we cannot give it any other sensible value when
-    // performing a null_buffers operation.
-    out_flags = 0;
-
-    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(base_implementation_type& impl,
-      const MutableBufferSequence& buffers, socket_base::message_flags in_flags,
-      socket_base::message_flags& out_flags, Handler 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),
-      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.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)
-  {
-    // Allocate and construct an operation to wrap the handler.
-    typedef reactive_null_buffers_op<Handler> op;
-    typename op::ptr p = { boost::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)"));
-
-    // Clear out_flags, since we cannot give it any other sensible value when
-    // 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.v = p.p = 0;
-  }
-
 protected:
   // Open a new socket implementation.
   BOOST_ASIO_DECL boost::system::error_code do_open(
       base_implementation_type& impl, int af,
       int type, int protocol, boost::system::error_code& ec);
 
   // Assign a native socket to a socket implementation.
   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);
+      const native_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 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);
 
   // 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);
 
   // The selector that performs event demultiplexing for the service.
   reactor& reactor_;
 };
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #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)
 
 #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..f225ea0 100644
--- a/3rdParty/Boost/src/boost/asio/detail/reactor.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/reactor.hpp
@@ -1,30 +1,30 @@
 //
 // detail/reactor.hpp
 // ~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_REACTOR_HPP
 #define BOOST_ASIO_DETAIL_REACTOR_HPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/reactor_fwd.hpp>
 
 #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>
 #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..a4ff94a 100644
--- a/3rdParty/Boost/src/boost/asio/detail/reactor_fwd.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/reactor_fwd.hpp
@@ -1,40 +1,40 @@
 //
 // detail/reactor_fwd.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_REACTOR_FWD_HPP
 #define BOOST_ASIO_DETAIL_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_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;
 #elif defined(BOOST_ASIO_HAS_EPOLL)
 typedef epoll_reactor reactor;
 #elif defined(BOOST_ASIO_HAS_KQUEUE)
diff --git a/3rdParty/Boost/src/boost/asio/detail/reactor_op.hpp b/3rdParty/Boost/src/boost/asio/detail/reactor_op.hpp
index 3b8e7f9..0c8271c 100644
--- a/3rdParty/Boost/src/boost/asio/detail/reactor_op.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/reactor_op.hpp
@@ -1,40 +1,40 @@
 //
 // detail/reactor_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_REACTOR_OP_HPP
 #define BOOST_ASIO_DETAIL_REACTOR_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 {
 
 class reactor_op
   : public operation
 {
 public:
   // The error code to be passed to the completion handler.
   boost::system::error_code ec_;
 
   // The number of bytes transferred, to be passed to the completion handler.
   std::size_t bytes_transferred_;
 
   // Perform the operation. Returns true if it is finished.
   bool perform()
   {
     return perform_func_(this);
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..02b8ea2 100644
--- a/3rdParty/Boost/src/boost/asio/detail/reactor_op_queue.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/reactor_op_queue.hpp
@@ -1,40 +1,40 @@
 //
 // detail/reactor_op_queue.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_REACTOR_OP_QUEUE_HPP
 #define BOOST_ASIO_DETAIL_REACTOR_OP_QUEUE_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/hash_map.hpp>
 #include <boost/asio/detail/noncopyable.hpp>
 #include <boost/asio/detail/op_queue.hpp>
 #include <boost/asio/detail/reactor_op.hpp>
 #include <boost/asio/error.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 template <typename Descriptor>
 class reactor_op_queue
   : private noncopyable
 {
 public:
   // Constructor.
   reactor_op_queue()
     : operations_()
   {
   }
diff --git a/3rdParty/Boost/src/boost/asio/detail/regex_fwd.hpp b/3rdParty/Boost/src/boost/asio/detail/regex_fwd.hpp
index 679146e..d61ad61 100644
--- a/3rdParty/Boost/src/boost/asio/detail/regex_fwd.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/regex_fwd.hpp
@@ -1,31 +1,31 @@
 //
 // detail/regex_fwd.hpp
 // ~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_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)
 
 #include <boost/regex_fwd.hpp>
 #include <boost/regex/v4/match_flags.hpp>
 
 namespace boost {
 
 template <class BidiIterator>
 struct sub_match;
 
 template <class BidiIterator, class Allocator>
 class match_results;
 
 } // namespace boost
 
 #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..46acda3 100644
--- a/3rdParty/Boost/src/boost/asio/detail/resolve_endpoint_op.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/resolve_endpoint_op.hpp
@@ -1,123 +1,118 @@
 //
 // detail/resolve_endpoint_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_RESOLVER_ENDPOINT_OP_HPP
 #define BOOST_ASIO_DETAIL_RESOLVER_ENDPOINT_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/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/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>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 template <typename Protocol, typename Handler>
 class resolve_endpoint_op : public operation
 {
 public:
   BOOST_ASIO_DEFINE_HANDLER_PTR(resolve_endpoint_op);
 
   typedef typename Protocol::endpoint endpoint_type;
   typedef boost::asio::ip::basic_resolver_iterator<Protocol> iterator_type;
 
   resolve_endpoint_op(socket_ops::weak_cancel_token_type cancel_token,
-      const endpoint_type& endpoint, io_service_impl& ios, Handler& handler)
+      const endpoint_type& endpoint, io_service_impl& ios, Handler handler)
     : operation(&resolve_endpoint_op::do_complete),
       cancel_token_(cancel_token),
       endpoint_(endpoint),
       io_service_impl_(ios),
-      handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler))
+      handler_(handler)
   {
   }
 
   static void do_complete(io_service_impl* owner, operation* base,
-      const boost::system::error_code& /*ec*/,
-      std::size_t /*bytes_transferred*/)
+      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 };
 
     if (owner && owner != &o->io_service_impl_)
     {
       // The operation is being run on the worker io_service. Time to perform
       // the resolver operation.
     
       // Perform the blocking endpoint resolution operation.
       char host_name[NI_MAXHOST];
       char service_name[NI_MAXSERV];
       socket_ops::background_getnameinfo(o->cancel_token_, o->endpoint_.data(),
           o->endpoint_.size(), host_name, NI_MAXHOST, service_name, NI_MAXSERV,
           o->endpoint_.protocol().type(), o->ec_);
       o->iter_ = iterator_type::create(o->endpoint_, host_name, service_name);
 
       // Pass operation back to main io_service for completion.
       o->io_service_impl_.post_deferred_completion(o);
       p.v = p.p = 0;
     }
     else
     {
       // The operation has been returned to the main io_service. The completion
       // handler is ready to be delivered.
 
-      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, iterator_type>
         handler(o->handler_, o->ec_, o->iter_);
       p.h = boost::addressof(handler.handler_);
       p.reset();
 
       if (owner)
       {
-        fenced_block b(fenced_block::half);
-        BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, "..."));
+        boost::asio::detail::fenced_block b;
         boost_asio_handler_invoke_helpers::invoke(handler, handler.handler_);
-        BOOST_ASIO_HANDLER_INVOCATION_END;
       }
     }
   }
 
 private:
   socket_ops::weak_cancel_token_type cancel_token_;
   endpoint_type endpoint_;
   io_service_impl& io_service_impl_;
   Handler handler_;
   boost::system::error_code ec_;
   iterator_type iter_;
 };
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // BOOST_ASIO_DETAIL_RESOLVER_ENDPOINT_OP_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/resolve_op.hpp b/3rdParty/Boost/src/boost/asio/detail/resolve_op.hpp
index b640979..379ec39 100644
--- a/3rdParty/Boost/src/boost/asio/detail/resolve_op.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/resolve_op.hpp
@@ -1,133 +1,128 @@
 //
 // detail/resolve_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_RESOLVE_OP_HPP
 #define BOOST_ASIO_DETAIL_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>
 #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/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>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 template <typename Protocol, typename Handler>
 class resolve_op : public operation
 {
 public:
   BOOST_ASIO_DEFINE_HANDLER_PTR(resolve_op);
 
   typedef boost::asio::ip::basic_resolver_query<Protocol> query_type;
   typedef boost::asio::ip::basic_resolver_iterator<Protocol> iterator_type;
 
   resolve_op(socket_ops::weak_cancel_token_type cancel_token,
-      const query_type& query, io_service_impl& ios, Handler& handler)
+      const query_type& query, io_service_impl& ios, Handler handler)
     : operation(&resolve_op::do_complete),
       cancel_token_(cancel_token),
       query_(query),
       io_service_impl_(ios),
-      handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)),
+      handler_(handler),
       addrinfo_(0)
   {
   }
 
   ~resolve_op()
   {
     if (addrinfo_)
       socket_ops::freeaddrinfo(addrinfo_);
   }
 
   static void do_complete(io_service_impl* owner, operation* base,
-      const boost::system::error_code& /*ec*/,
-      std::size_t /*bytes_transferred*/)
+      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 };
 
     if (owner && owner != &o->io_service_impl_)
     {
       // The operation is being run on the worker io_service. Time to perform
       // the resolver operation.
     
       // Perform the blocking host resolution operation.
       socket_ops::background_getaddrinfo(o->cancel_token_,
           o->query_.host_name().c_str(), o->query_.service_name().c_str(),
           o->query_.hints(), &o->addrinfo_, o->ec_);
 
       // Pass operation back to main io_service for completion.
       o->io_service_impl_.post_deferred_completion(o);
       p.v = p.p = 0;
     }
     else
     {
       // The operation has been returned to the main io_service. The completion
       // handler is ready to be delivered.
 
-      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, iterator_type>
         handler(o->handler_, o->ec_, iterator_type());
       p.h = boost::addressof(handler.handler_);
       if (o->addrinfo_)
       {
         handler.arg2_ = iterator_type::create(o->addrinfo_,
             o->query_.host_name(), o->query_.service_name());
       }
       p.reset();
 
       if (owner)
       {
-        fenced_block b(fenced_block::half);
-        BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, "..."));
+        boost::asio::detail::fenced_block b;
         boost_asio_handler_invoke_helpers::invoke(handler, handler.handler_);
-        BOOST_ASIO_HANDLER_INVOCATION_END;
       }
     }
   }
 
 private:
   socket_ops::weak_cancel_token_type cancel_token_;
   query_type query_;
   io_service_impl& io_service_impl_;
   Handler handler_;
   boost::system::error_code ec_;
   boost::asio::detail::addrinfo_type* addrinfo_;
 };
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // BOOST_ASIO_DETAIL_RESOLVE_OP_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/resolver_service.hpp b/3rdParty/Boost/src/boost/asio/detail/resolver_service.hpp
index 8225844..1c343cb 100644
--- a/3rdParty/Boost/src/boost/asio/detail/resolver_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/resolver_service.hpp
@@ -1,125 +1,121 @@
 //
 // detail/resolver_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_RESOLVER_SERVICE_HPP
 #define BOOST_ASIO_DETAIL_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>
 #include <boost/asio/ip/basic_resolver_iterator.hpp>
 #include <boost/asio/ip/basic_resolver_query.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>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 template <typename Protocol>
 class resolver_service : public resolver_service_base
 {
 public:
   // The implementation type of the resolver. A cancellation token is used to
   // indicate to the background thread 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.
   resolver_service(boost::asio::io_service& io_service)
     : resolver_service_base(io_service)
   {
   }
 
   // Resolve a query to a list of entries.
   iterator_type resolve(implementation_type&, const query_type& query,
       boost::system::error_code& ec)
   {
     boost::asio::detail::addrinfo_type* address_info = 0;
 
     socket_ops::getaddrinfo(query.host_name().c_str(),
         query.service_name().c_str(), query.hints(), &address_info, ec);
     auto_addrinfo auto_address_info(address_info);
 
     return ec ? iterator_type() : iterator_type::create(
         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)
+  void async_resolve(implementation_type& impl, 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),
       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"));
-
     start_resolve_op(p.p);
     p.v = p.p = 0;
   }
 
   // Resolve an endpoint to a list of entries.
   iterator_type resolve(implementation_type&,
       const endpoint_type& endpoint, boost::system::error_code& ec)
   {
     char host_name[NI_MAXHOST];
     char service_name[NI_MAXSERV];
     socket_ops::sync_getnameinfo(endpoint.data(), endpoint.size(),
         host_name, NI_MAXHOST, service_name, NI_MAXSERV,
         endpoint.protocol().type(), ec);
 
     return ec ? iterator_type() : iterator_type::create(
         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)
+  void async_resolve(implementation_type& impl, 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),
       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"));
-
     start_resolve_op(p.p);
     p.v = p.p = 0;
   }
 };
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #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..60e9e09 100644
--- a/3rdParty/Boost/src/boost/asio/detail/resolver_service_base.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/resolver_service_base.hpp
@@ -1,129 +1,125 @@
 //
 // detail/resolver_service_base.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_RESOLVER_SERVICE_BASE_HPP
 #define BOOST_ASIO_DETAIL_RESOLVER_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>
+#include <boost/scoped_ptr.hpp>
 #include <boost/asio/error.hpp>
 #include <boost/asio/io_service.hpp>
 #include <boost/asio/detail/mutex.hpp>
 #include <boost/asio/detail/noncopyable.hpp>
 #include <boost/asio/detail/operation.hpp>
 #include <boost/asio/detail/socket_ops.hpp>
 #include <boost/asio/detail/socket_types.hpp>
-#include <boost/asio/detail/scoped_ptr.hpp>
 #include <boost/asio/detail/thread.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 class resolver_service_base
 {
 public:
   // The implementation type of the resolver. A cancellation token is used to
   // indicate to the background thread that the operation has been cancelled.
   typedef socket_ops::shared_cancel_token_type implementation_type;
 
   // Constructor.
   BOOST_ASIO_DECL resolver_service_base(boost::asio::io_service& io_service);
 
   // Destructor.
   BOOST_ASIO_DECL ~resolver_service_base();
 
   // Destroy all user-defined handler objects owned by the service.
   BOOST_ASIO_DECL void shutdown_service();
 
-  // Perform any fork-related housekeeping.
-  BOOST_ASIO_DECL void fork_service(
-      boost::asio::io_service::fork_event fork_ev);
-
   // Construct a new resolver implementation.
   BOOST_ASIO_DECL void construct(implementation_type& impl);
 
   // Destroy a resolver implementation.
   BOOST_ASIO_DECL void destroy(implementation_type&);
 
   // Cancel pending asynchronous operations.
   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);
 
   // 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)
       : ai_(ai)
     {
     }
 
     ~auto_addrinfo()
     {
       if (ai_)
         socket_ops::freeaddrinfo(ai_);
     }
 
     operator boost::asio::detail::addrinfo_type*()
     {
       return ai_;
     }
 
   private:
     boost::asio::detail::addrinfo_type* ai_;
   };
 
   // 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();
 
   // The io_service implementation used to post completions.
   io_service_impl& io_service_impl_;
 
 private:
   // Mutex to protect access to internal data.
   boost::asio::detail::mutex mutex_;
 
   // Private io_service used for performing asynchronous host resolution.
-  boost::asio::detail::scoped_ptr<boost::asio::io_service> work_io_service_;
+  boost::scoped_ptr<boost::asio::io_service> work_io_service_;
 
   // The work io_service implementation used to post completions.
   io_service_impl& work_io_service_impl_;
 
   // Work for the private io_service to perform.
-  boost::asio::detail::scoped_ptr<boost::asio::io_service::work> work_;
+  boost::scoped_ptr<boost::asio::io_service::work> work_;
 
   // Thread used for running the work io_service's run loop.
-  boost::asio::detail::scoped_ptr<boost::asio::detail::thread> work_thread_;
+  boost::scoped_ptr<boost::asio::detail::thread> work_thread_;
 };
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #if defined(BOOST_ASIO_HEADER_ONLY)
 # include <boost/asio/detail/impl/resolver_service_base.ipp>
 #endif // defined(BOOST_ASIO_HEADER_ONLY)
 
 #endif // BOOST_ASIO_DETAIL_RESOLVER_SERVICE_BASE_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/scoped_lock.hpp b/3rdParty/Boost/src/boost/asio/detail/scoped_lock.hpp
index a2e6fd4..b523ae5 100644
--- a/3rdParty/Boost/src/boost/asio/detail/scoped_lock.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/scoped_lock.hpp
@@ -1,40 +1,40 @@
 //
 // detail/scoped_lock.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_SCOPED_LOCK_HPP
 #define BOOST_ASIO_DETAIL_SCOPED_LOCK_HPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/noncopyable.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 // Helper class to lock and unlock a mutex automatically.
 template <typename Mutex>
 class scoped_lock
   : private noncopyable
 {
 public:
   // Constructor acquires the lock.
   scoped_lock(Mutex& m)
     : mutex_(m)
   {
     mutex_.lock();
     locked_ = true;
   }
 
   // Destructor releases the lock.
diff --git a/3rdParty/Boost/src/boost/asio/detail/scoped_ptr.hpp b/3rdParty/Boost/src/boost/asio/detail/scoped_ptr.hpp
deleted file mode 100644
index 16436dd..0000000
--- a/3rdParty/Boost/src/boost/asio/detail/scoped_ptr.hpp
+++ /dev/null
@@ -1,81 +0,0 @@
-//
-// detail/scoped_ptr.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_SCOPED_PTR_HPP
-#define BOOST_ASIO_DETAIL_SCOPED_PTR_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 {
-namespace detail {
-
-template <typename T>
-class scoped_ptr
-{
-public:
-  // Constructor.
-  explicit scoped_ptr(T* p = 0)
-    : p_(p)
-  {
-  }
-
-  // Destructor.
-  ~scoped_ptr()
-  {
-    delete p_;
-  }
-
-  // Access.
-  T* get()
-  {
-    return p_;
-  }
-
-  // Access.
-  T* operator->()
-  {
-    return p_;
-  }
-
-  // Dereference.
-  T& operator*()
-  {
-    return *p_;
-  }
-
-  // Reset pointer.
-  void reset(T* p = 0)
-  {
-    delete p_;
-    p_ = p;
-  }
-
-private:
-  // Disallow copying and assignment.
-  scoped_ptr(const scoped_ptr&);
-  scoped_ptr& operator=(const scoped_ptr&);
-
-  T* p_;
-};
-
-} // namespace detail
-} // namespace asio
-} // namespace boost
-
-#include <boost/asio/detail/pop_options.hpp>
-
-#endif // 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..f0a1275 100644
--- a/3rdParty/Boost/src/boost/asio/detail/select_interrupter.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/select_interrupter.hpp
@@ -1,40 +1,40 @@
 //
 // detail/select_interrupter.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_SELECT_INTERRUPTER_HPP
 #define BOOST_ASIO_DETAIL_SELECT_INTERRUPTER_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_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__)
 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
diff --git a/3rdParty/Boost/src/boost/asio/detail/select_reactor.hpp b/3rdParty/Boost/src/boost/asio/detail/select_reactor.hpp
index a434546..f4f8bdf 100644
--- a/3rdParty/Boost/src/boost/asio/detail/select_reactor.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/select_reactor.hpp
@@ -1,221 +1,196 @@
 //
 // detail/select_reactor.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_SELECT_REACTOR_HPP
 #define BOOST_ASIO_DETAIL_SELECT_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_HAS_IOCP) \
   || (!defined(BOOST_ASIO_HAS_DEV_POLL) \
       && !defined(BOOST_ASIO_HAS_EPOLL) \
       && !defined(BOOST_ASIO_HAS_KQUEUE))
 
-#include <boost/limits.hpp>
 #include <cstddef>
-#include <boost/asio/detail/fd_set_adapter.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_op.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>
 #endif // defined(BOOST_ASIO_HAS_IOCP)
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 class select_reactor
   : public boost::asio::detail::service_base<select_reactor>
 {
 public:
 #if defined(BOOST_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__)
   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__)
 
   // Per-descriptor data.
   struct per_descriptor_data
   {
   };
 
   // Constructor.
   BOOST_ASIO_DECL select_reactor(boost::asio::io_service& io_service);
 
   // Destructor.
   BOOST_ASIO_DECL ~select_reactor();
 
   // 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, but only if the reactor is not in its own thread.
   BOOST_ASIO_DECL void init_task();
 
   // Register a socket with the reactor. Returns 0 on success, system error
   // code on failure.
   BOOST_ASIO_DECL int register_descriptor(socket_type, per_descriptor_data&);
 
-  // Register a descriptor with an associated single operation. Returns 0 on
-  // 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)
   {
     io_service_.post_immediate_completion(op);
   }
 
   // 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);
 
   // 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&);
 
   // Cancel any operations that are running against the descriptor and remove
   // its registration from the reactor.
-  BOOST_ASIO_DECL void deregister_descriptor(socket_type descriptor,
-      per_descriptor_data&, bool closing);
-
-  // Remote the descriptor's registration from the reactor.
-  BOOST_ASIO_DECL void deregister_internal_descriptor(
-      socket_type descriptor, per_descriptor_data& descriptor_data);
-
-  // 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);
+  BOOST_ASIO_DECL void close_descriptor(socket_type descriptor,
+      per_descriptor_data&);
 
   // 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);
+      typename timer_queue<Time_Traits>::per_timer_data& timer, timer_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)());
+      typename timer_queue<Time_Traits>::per_timer_data& timer);
 
   // Run select once until interrupted or events are ready to be dispatched.
   BOOST_ASIO_DECL void run(bool block, op_queue<operation>& ops);
 
   // Interrupt the select loop.
   BOOST_ASIO_DECL void interrupt();
 
 private:
 #if defined(BOOST_ASIO_HAS_IOCP)
   // 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(select_reactor* reactor);
 #endif // defined(BOOST_ASIO_HAS_IOCP)
 
   // 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);
 
   // Get the timeout value for the select call.
   BOOST_ASIO_DECL timeval* get_timeout(timeval& tv);
 
   // Cancel all operations associated with the given descriptor. This function
   // does not acquire the select_reactor's mutex.
   BOOST_ASIO_DECL void cancel_ops_unlocked(socket_type descriptor,
       const boost::system::error_code& ec);
 
   // The io_service implementation used to post completions.
   io_service_impl& io_service_;
 
   // Mutex to protect access to internal data.
   boost::asio::detail::mutex mutex_;
 
   // The interrupter is used to break a blocking select call.
   select_interrupter interrupter_;
 
   // The queues of read, write and except operations.
   reactor_op_queue<socket_type> op_queue_[max_ops];
 
-  // The file descriptor sets to be passed to the select system call.
-  fd_set_adapter fd_sets_[max_select_ops];
-
   // The timer queues.
   timer_queue_set timer_queues_;
 
 #if defined(BOOST_ASIO_HAS_IOCP)
   // Does the reactor loop thread need to stop.
   bool stop_thread_;
 
   // The thread that is running the reactor loop.
   boost::asio::detail::thread* thread_;
 #endif // defined(BOOST_ASIO_HAS_IOCP)
 
   // 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/select_reactor.hpp>
 #if defined(BOOST_ASIO_HEADER_ONLY)
 # 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))
 
 #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
index 1337969..78ff61b 100644
--- a/3rdParty/Boost/src/boost/asio/detail/select_reactor_fwd.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/select_reactor_fwd.hpp
@@ -1,28 +1,28 @@
 //
 // detail/select_reactor_fwd.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_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..a247ea8 100644
--- a/3rdParty/Boost/src/boost/asio/detail/service_registry.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/service_registry.hpp
@@ -1,164 +1,154 @@
 //
 // detail/service_registry.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_SERVICE_REGISTRY_HPP
 #define BOOST_ASIO_DETAIL_SERVICE_REGISTRY_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/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 {
 
 #if defined(__GNUC__)
 # if (__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4)
 #  pragma GCC visibility push (default)
 # endif // (__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4)
 #endif // defined(__GNUC__)
 
 template <typename T>
 class typeid_wrapper {};
 
 #if defined(__GNUC__)
 # if (__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4)
 #  pragma GCC visibility pop
 # endif // (__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4)
 #endif // defined(__GNUC__)
 
 class service_registry
   : private noncopyable
 {
 public:
-  // Constructor. Adds the initial service.
-  template <typename Service, typename Arg>
-  service_registry(boost::asio::io_service& o,
-      Service* initial_service, Arg arg);
+  // Constructor.
+  BOOST_ASIO_DECL service_registry(boost::asio::io_service& o);
 
   // Destructor.
   BOOST_ASIO_DECL ~service_registry();
 
-  // Notify all services of a fork event.
-  BOOST_ASIO_DECL void notify_fork(boost::asio::io_service::fork_event fork_ev);
-
-  // Get the first service object cast to the specified type. Called during
-  // io_service construction and so performs no locking or type checking.
-  template <typename Service>
-  Service& first_service();
-
   // Get the service object corresponding to the specified service type. Will
   // create a new service object automatically if no such object already
   // exists. Ownership of the service object is not transferred to the caller.
   template <typename Service>
   Service& use_service();
 
   // Add a service object. Throws on error, in which case ownership of the
   // object is retained by the caller.
   template <typename Service>
   void add_service(Service* new_service);
 
   // Check whether a service object of the specified type already exists.
   template <typename Service>
   bool has_service() const;
 
 private:
   // Initialise a service's key based on its id.
   BOOST_ASIO_DECL static void init_key(
       boost::asio::io_service::service::key& key,
       const boost::asio::io_service::id& id);
 
 #if !defined(BOOST_ASIO_NO_TYPEID)
   // Initialise a service's key based on its id.
   template <typename Service>
   static void init_key(boost::asio::io_service::service::key& key,
       const boost::asio::detail::service_id<Service>& /*id*/);
 #endif // !defined(BOOST_ASIO_NO_TYPEID)
 
   // Check if a service matches the given id.
   BOOST_ASIO_DECL static bool keys_match(
       const boost::asio::io_service::service::key& key1,
       const boost::asio::io_service::service::key& key2);
 
   // The type of a factory function used for creating a service instance.
   typedef boost::asio::io_service::service*
     (*factory_type)(boost::asio::io_service&);
 
   // Factory function for creating a service instance.
   template <typename Service>
   static boost::asio::io_service::service* create(
       boost::asio::io_service& owner);
 
   // Destroy a service instance.
   BOOST_ASIO_DECL static void destroy(
       boost::asio::io_service::service* service);
 
   // Helper class to manage service pointers.
   struct auto_service_ptr;
   friend struct auto_service_ptr;
   struct auto_service_ptr
   {
     boost::asio::io_service::service* ptr_;
     ~auto_service_ptr() { destroy(ptr_); }
   };
 
   // Get the service object corresponding to the specified service key. Will
   // create a new service object automatically if no such object already
   // exists. Ownership of the service object is not transferred to the caller.
   BOOST_ASIO_DECL boost::asio::io_service::service* do_use_service(
       const boost::asio::io_service::service::key& key,
       factory_type factory);
 
-  // Add a service object. Throws on error, in which case ownership of the
-  // object is retained by the caller.
+  // Add a service object. Returns false on error, in which case ownership of
+  // the object is retained by the caller.
   BOOST_ASIO_DECL void do_add_service(
       const boost::asio::io_service::service::key& key,
       boost::asio::io_service::service* new_service);
 
   // Check whether a service object with the specified key already exists.
   BOOST_ASIO_DECL bool do_has_service(
       const boost::asio::io_service::service::key& key) const;
 
   // Mutex to protect access to internal data.
   mutable boost::asio::detail::mutex mutex_;
 
   // The owner of this service registry and the services it contains.
   boost::asio::io_service& owner_;
 
   // The first service in the list of contained services.
   boost::asio::io_service::service* first_service_;
 };
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #include <boost/asio/detail/impl/service_registry.hpp>
 #if defined(BOOST_ASIO_HEADER_ONLY)
 # include <boost/asio/detail/impl/service_registry.ipp>
 #endif // defined(BOOST_ASIO_HEADER_ONLY)
 
 #endif // BOOST_ASIO_DETAIL_SERVICE_REGISTRY_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/service_registry_fwd.hpp b/3rdParty/Boost/src/boost/asio/detail/service_registry_fwd.hpp
index 3157574..a6bb25e 100644
--- a/3rdParty/Boost/src/boost/asio/detail/service_registry_fwd.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/service_registry_fwd.hpp
@@ -1,28 +1,28 @@
 //
 // detail/service_registry_fwd.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_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..fe497b7 100644
--- a/3rdParty/Boost/src/boost/asio/detail/shared_ptr.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/shared_ptr.hpp
@@ -1,40 +1,40 @@
 //
 // detail/shared_ptr.hpp
 // ~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_SHARED_PTR_HPP
 #define BOOST_ASIO_DETAIL_SHARED_PTR_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_SHARED_PTR)
+#if defined(_MSC_VER) && (_MSC_VER >= 1600)
 # include <memory>
-#else // defined(BOOST_ASIO_HAS_STD_SHARED_PTR)
+#else
 # include <boost/shared_ptr.hpp>
-#endif // defined(BOOST_ASIO_HAS_STD_SHARED_PTR)
+#endif
 
 namespace boost {
 namespace asio {
 namespace detail {
 
-#if defined(BOOST_ASIO_HAS_STD_SHARED_PTR)
+#if defined(_MSC_VER) && (_MSC_VER >= 1600)
 using std::shared_ptr;
-#else // defined(BOOST_ASIO_HAS_STD_SHARED_PTR)
+#else
 using boost::shared_ptr;
-#endif // defined(BOOST_ASIO_HAS_STD_SHARED_PTR)
+#endif
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #endif // 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..cc00482 100644
--- a/3rdParty/Boost/src/boost/asio/detail/signal_blocker.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/signal_blocker.hpp
@@ -1,40 +1,40 @@
 //
 // detail/signal_blocker.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_SIGNAL_BLOCKER_HPP
 #define BOOST_ASIO_DETAIL_SIGNAL_BLOCKER_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_HAS_THREADS) || defined(BOOST_ASIO_DISABLE_THREADS) \
   || defined(BOOST_WINDOWS) || defined(__CYGWIN__) || defined(__SYMBIAN32__)
 # include <boost/asio/detail/null_signal_blocker.hpp>
 #elif defined(BOOST_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__)
 typedef null_signal_blocker signal_blocker;
 #elif defined(BOOST_HAS_PTHREADS)
 typedef posix_signal_blocker signal_blocker;
 #endif
 
 } // namespace detail
diff --git a/3rdParty/Boost/src/boost/asio/detail/signal_handler.hpp b/3rdParty/Boost/src/boost/asio/detail/signal_handler.hpp
deleted file mode 100644
index bd1c727..0000000
--- a/3rdParty/Boost/src/boost/asio/detail/signal_handler.hpp
+++ /dev/null
@@ -1,83 +0,0 @@
-//
-// detail/signal_handler.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_SIGNAL_HANDLER_HPP
-#define BOOST_ASIO_DETAIL_SIGNAL_HANDLER_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/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>
-
-namespace boost {
-namespace asio {
-namespace detail {
-
-template <typename Handler>
-class signal_handler : public signal_op
-{
-public:
-  BOOST_ASIO_DEFINE_HANDLER_PTR(signal_handler);
-
-  signal_handler(Handler& h)
-    : signal_op(&signal_handler::do_complete),
-      handler_(BOOST_ASIO_MOVE_CAST(Handler)(h))
-  {
-  }
-
-  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 };
-
-    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.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 // BOOST_ASIO_DETAIL_SIGNAL_HANDLER_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/signal_init.hpp b/3rdParty/Boost/src/boost/asio/detail/signal_init.hpp
index e038a88..f346956 100644
--- a/3rdParty/Boost/src/boost/asio/detail/signal_init.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/signal_init.hpp
@@ -1,40 +1,40 @@
 //
 // detail/signal_init.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_SIGNAL_INIT_HPP
 #define BOOST_ASIO_DETAIL_SIGNAL_INIT_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_WINDOWS) && !defined(__CYGWIN__)
 
 #include <csignal>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 template <int Signal = SIGPIPE>
 class signal_init
 {
 public:
   // Constructor.
   signal_init()
   {
     std::signal(Signal, SIG_IGN);
   }
 };
 
diff --git a/3rdParty/Boost/src/boost/asio/detail/signal_op.hpp b/3rdParty/Boost/src/boost/asio/detail/signal_op.hpp
deleted file mode 100644
index 706691b..0000000
--- a/3rdParty/Boost/src/boost/asio/detail/signal_op.hpp
+++ /dev/null
@@ -1,51 +0,0 @@
-//
-// detail/signal_op.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_SIGNAL_OP_HPP
-#define BOOST_ASIO_DETAIL_SIGNAL_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 {
-
-class signal_op
-  : public operation
-{
-public:
-  // The error code to be passed to the completion handler.
-  boost::system::error_code ec_;
-
-  // The signal number to be passed to the completion handler.
-  int signal_number_;
-
-protected:
-  signal_op(func_type func)
-    : operation(func),
-      signal_number_(0)
-  {
-  }
-};
-
-} // namespace detail
-} // namespace asio
-} // namespace boost
-
-#include <boost/asio/detail/pop_options.hpp>
-
-#endif // 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
deleted file mode 100644
index afa67fe..0000000
--- a/3rdParty/Boost/src/boost/asio/detail/signal_set_service.hpp
+++ /dev/null
@@ -1,213 +0,0 @@
-//
-// detail/signal_set_service.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_SIGNAL_SET_SERVICE_HPP
-#define BOOST_ASIO_DETAIL_SIGNAL_SET_SERVICE_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 <signal.h>
-#include <boost/asio/error.hpp>
-#include <boost/asio/io_service.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__)
-# include <boost/asio/detail/reactor.hpp>
-#endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
-
-#include <boost/asio/detail/push_options.hpp>
-
-namespace boost {
-namespace asio {
-namespace detail {
-
-#if defined(NSIG) && (NSIG > 0)
-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);
-
-class signal_set_service
-{
-public:
-  // Type used for tracking an individual signal registration.
-  class registration
-  {
-  public:
-    // Default constructor.
-    registration()
-      : signal_number_(0),
-        queue_(0),
-        undelivered_(0),
-        next_in_table_(0),
-        prev_in_table_(0),
-        next_in_set_(0)
-    {
-    }
-
-  private:
-    // Only this service will have access to the internal values.
-    friend class signal_set_service;
-
-    // The signal number that is registered.
-    int signal_number_;
-
-    // The waiting signal handlers.
-    op_queue<signal_op>* queue_;
-
-    // The number of undelivered signals.
-    std::size_t undelivered_;
-
-    // Pointers to adjacent registrations in the registrations_ table.
-    registration* next_in_table_;
-    registration* prev_in_table_;
-
-    // Link to next registration in the signal set.
-    registration* next_in_set_;
-  };
-
-  // The implementation type of the signal_set.
-  class implementation_type
-  {
-  public:
-    // Default constructor.
-    implementation_type()
-      : signals_(0)
-    {
-    }
-
-  private:
-    // Only this service will have access to the internal values.
-    friend class signal_set_service;
-
-    // The pending signal handlers.
-    op_queue<signal_op> queue_;
-
-    // Linked list of registered signals.
-    registration* signals_;
-  };
-
-  // Constructor.
-  BOOST_ASIO_DECL signal_set_service(boost::asio::io_service& io_service);
-
-  // Destructor.
-  BOOST_ASIO_DECL ~signal_set_service();
-
-  // Destroy all user-defined handler objects owned by the service.
-  BOOST_ASIO_DECL void shutdown_service();
-
-  // Perform fork-related housekeeping.
-  BOOST_ASIO_DECL void fork_service(
-      boost::asio::io_service::fork_event fork_ev);
-
-  // Construct a new signal_set implementation.
-  BOOST_ASIO_DECL void construct(implementation_type& impl);
-
-  // Destroy a signal_set implementation.
-  BOOST_ASIO_DECL void destroy(implementation_type& impl);
-
-  // Add a signal to a signal_set.
-  BOOST_ASIO_DECL boost::system::error_code add(implementation_type& impl,
-      int signal_number, boost::system::error_code& ec);
-
-  // Remove a signal to a signal_set.
-  BOOST_ASIO_DECL boost::system::error_code remove(implementation_type& impl,
-      int signal_number, boost::system::error_code& ec);
-
-  // Remove all signals from a signal_set.
-  BOOST_ASIO_DECL boost::system::error_code clear(implementation_type& impl,
-      boost::system::error_code& ec);
-
-  // 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)
-  {
-    // Allocate and construct an operation to wrap the handler.
-    typedef signal_handler<Handler> op;
-    typename op::ptr p = { boost::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"));
-
-    start_wait_op(impl, p.p);
-    p.v = p.p = 0;
-  }
-
-  // Deliver notification that a particular signal occurred.
-  BOOST_ASIO_DECL static void deliver_signal(int signal_number);
-
-private:
-  // Helper function to add a service to the global signal state.
-  BOOST_ASIO_DECL static void add_service(signal_set_service* service);
-
-  // Helper function to remove a service from the global signal state.
-  BOOST_ASIO_DECL static void remove_service(signal_set_service* service);
-
-  // Helper function to create the pipe descriptors.
-  BOOST_ASIO_DECL static void open_descriptors();
-
-  // Helper function to close the pipe descriptors.
-  BOOST_ASIO_DECL static void close_descriptors();
-
-  // 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__)
-  // 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__)
-
-  // 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_;
-  signal_set_service* prev_;
-};
-
-} // namespace detail
-} // namespace asio
-} // namespace boost
-
-#include <boost/asio/detail/pop_options.hpp>
-
-#if defined(BOOST_ASIO_HEADER_ONLY)
-# include <boost/asio/detail/impl/signal_set_service.ipp>
-#endif // defined(BOOST_ASIO_HEADER_ONLY)
-
-#endif // BOOST_ASIO_DETAIL_SIGNAL_SET_SERVICE_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/socket_holder.hpp b/3rdParty/Boost/src/boost/asio/detail/socket_holder.hpp
index d299859..52d2e4d 100644
--- a/3rdParty/Boost/src/boost/asio/detail/socket_holder.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/socket_holder.hpp
@@ -1,40 +1,40 @@
 //
 // detail/socket_holder.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_SOCKET_HOLDER_HPP
 #define BOOST_ASIO_DETAIL_SOCKET_HOLDER_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/noncopyable.hpp>
 #include <boost/asio/detail/socket_ops.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 // Implement the resource acquisition is initialisation idiom for sockets.
 class socket_holder
   : private noncopyable
 {
 public:
   // Construct as an uninitialised socket.
   socket_holder()
     : socket_(invalid_socket)
   {
   }
 
   // Construct to take ownership of the specified socket.
   explicit socket_holder(socket_type s)
diff --git a/3rdParty/Boost/src/boost/asio/detail/socket_ops.hpp b/3rdParty/Boost/src/boost/asio/detail/socket_ops.hpp
index b353316..18a8131 100644
--- a/3rdParty/Boost/src/boost/asio/detail/socket_ops.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/socket_ops.hpp
@@ -1,133 +1,127 @@
 //
 // detail/socket_ops.hpp
 // ~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_SOCKET_OPS_HPP
 #define BOOST_ASIO_DETAIL_SOCKET_OPS_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/system/error_code.hpp>
 #include <boost/asio/detail/shared_ptr.hpp>
 #include <boost/asio/detail/socket_types.hpp>
 #include <boost/asio/detail/weak_ptr.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 namespace socket_ops {
 
 // Socket state bits.
 enum
 {
   // The user wants a non-blocking socket.
   user_set_non_blocking = 1,
 
   // The socket has been set non-blocking.
   internal_non_blocking = 2,
 
   // Helper "state" used to determine whether the socket is non-blocking.
   non_blocking = user_set_non_blocking | internal_non_blocking,
 
   // User wants connection_aborted errors, which are disabled by default.
   enable_connection_aborted = 4,
 
   // The user set the linger option. Needs to be checked when closing.
   user_set_linger = 8,
 
   // The socket is stream-oriented.
   stream_oriented = 16,
 
   // The socket is datagram-oriented.
-  datagram_oriented = 32,
-
-  // The socket may have been dup()-ed.
-  possible_dup = 64
+  datagram_oriented = 32
 };
 
 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;
 
 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);
 
 #if defined(BOOST_ASIO_HAS_IOCP)
 
 BOOST_ASIO_DECL void complete_iocp_accept(socket_type s,
     void* output_buffer, DWORD address_length,
     socket_addr_type* addr, std::size_t* addrlen,
     socket_type new_socket, boost::system::error_code& ec);
 
 #else // defined(BOOST_ASIO_HAS_IOCP)
 
 BOOST_ASIO_DECL bool non_blocking_accept(socket_type s,
     state_type state, socket_addr_type* addr, std::size_t* addrlen,
     boost::system::error_code& ec, socket_type& new_socket);
 
 #endif // defined(BOOST_ASIO_HAS_IOCP)
 
 BOOST_ASIO_DECL int bind(socket_type s, const socket_addr_type* addr,
     std::size_t addrlen, boost::system::error_code& ec);
 
 BOOST_ASIO_DECL int close(socket_type s, state_type& state,
     bool destruction, boost::system::error_code& ec);
 
-BOOST_ASIO_DECL bool set_user_non_blocking(socket_type s,
-    state_type& state, bool value, boost::system::error_code& ec);
-
 BOOST_ASIO_DECL bool set_internal_non_blocking(socket_type s,
-    state_type& state, bool value, boost::system::error_code& ec);
+    state_type& state, boost::system::error_code& ec);
 
 BOOST_ASIO_DECL int shutdown(socket_type s,
     int what, boost::system::error_code& ec);
 
 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);
 
 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__)
 typedef WSABUF buf;
 #else // defined(BOOST_WINDOWS) || defined(__CYGWIN__)
 typedef iovec buf;
 #endif // defined(BOOST_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);
@@ -140,157 +134,134 @@ BOOST_ASIO_DECL size_t sync_recv(socket_type s, state_type state, buf* bufs,
 BOOST_ASIO_DECL void complete_iocp_recv(state_type state,
     const weak_cancel_token_type& cancel_token, bool all_empty,
     boost::system::error_code& ec, size_t bytes_transferred);
 
 #else // defined(BOOST_ASIO_HAS_IOCP)
 
 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 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)
 
 BOOST_ASIO_DECL void complete_iocp_recvfrom(
     const weak_cancel_token_type& cancel_token,
     boost::system::error_code& ec);
 
 #else // defined(BOOST_ASIO_HAS_IOCP)
 
 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 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)
-
-BOOST_ASIO_DECL void complete_iocp_recvmsg(
-    const weak_cancel_token_type& cancel_token,
-    boost::system::error_code& ec);
-
-#else // defined(BOOST_ASIO_HAS_IOCP)
-
-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,
     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);
 
 #if defined(BOOST_ASIO_HAS_IOCP)
 
 BOOST_ASIO_DECL void complete_iocp_send(
     const weak_cancel_token_type& cancel_token,
     boost::system::error_code& ec);
 
 #else // defined(BOOST_ASIO_HAS_IOCP)
 
 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 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)
 
 BOOST_ASIO_DECL bool non_blocking_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, size_t& bytes_transferred);
 
 #endif // !defined(BOOST_ASIO_HAS_IOCP)
 
 BOOST_ASIO_DECL socket_type socket(int af, int type, int protocol,
     boost::system::error_code& ec);
 
 BOOST_ASIO_DECL int setsockopt(socket_type s, state_type& state,
     int level, int optname, const void* optval,
     std::size_t optlen, boost::system::error_code& ec);
 
 BOOST_ASIO_DECL int getsockopt(socket_type s, state_type state,
     int level, int optname, void* optval,
     size_t* optlen, boost::system::error_code& ec);
 
 BOOST_ASIO_DECL int getpeername(socket_type s, socket_addr_type* addr,
     std::size_t* addrlen, bool cached, boost::system::error_code& ec);
 
 BOOST_ASIO_DECL int getsockname(socket_type s, socket_addr_type* addr,
     std::size_t* addrlen, boost::system::error_code& ec);
 
 BOOST_ASIO_DECL int ioctl(socket_type s, state_type& state,
     int cmd, ioctl_arg_type* arg, boost::system::error_code& ec);
 
 BOOST_ASIO_DECL int select(int nfds, fd_set* readfds, fd_set* writefds,
     fd_set* exceptfds, timeval* timeout, boost::system::error_code& ec);
 
-BOOST_ASIO_DECL int poll_read(socket_type s,
-    state_type state, boost::system::error_code& ec);
+BOOST_ASIO_DECL int poll_read(socket_type s, boost::system::error_code& ec);
 
-BOOST_ASIO_DECL int poll_write(socket_type s,
-    state_type state, boost::system::error_code& ec);
+BOOST_ASIO_DECL int poll_write(socket_type s, boost::system::error_code& ec);
 
 BOOST_ASIO_DECL int poll_connect(socket_type s, boost::system::error_code& ec);
 
 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);
 
 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,
     const char* service, const addrinfo_type& hints,
     addrinfo_type** result, boost::system::error_code& ec);
 
 BOOST_ASIO_DECL void freeaddrinfo(addrinfo_type* ai);
 
 BOOST_ASIO_DECL 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);
 
 BOOST_ASIO_DECL boost::system::error_code sync_getnameinfo(
     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);
 
 BOOST_ASIO_DECL boost::system::error_code background_getnameinfo(
     const weak_cancel_token_type& cancel_token,
diff --git a/3rdParty/Boost/src/boost/asio/detail/socket_option.hpp b/3rdParty/Boost/src/boost/asio/detail/socket_option.hpp
index 5d3a514..c841033 100644
--- a/3rdParty/Boost/src/boost/asio/detail/socket_option.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/socket_option.hpp
@@ -1,40 +1,40 @@
 //
 // detail/socket_option.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_SOCKET_OPTION_HPP
 #define BOOST_ASIO_DETAIL_SOCKET_OPTION_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 <stdexcept>
 #include <boost/config.hpp>
 #include <boost/throw_exception.hpp>
 #include <boost/asio/detail/socket_types.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 namespace socket_option {
 
 // Helper template for implementing boolean-based options.
 template <int Level, int Name>
 class boolean
 {
 public:
   // Default constructor.
   boolean()
     : value_(0)
   {
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..6d68d5a 100644
--- a/3rdParty/Boost/src/boost/asio/detail/socket_select_interrupter.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/socket_select_interrupter.hpp
@@ -1,89 +1,80 @@
 //
 // detail/socket_select_interrupter.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_SOCKET_SELECT_INTERRUPTER_HPP
 #define BOOST_ASIO_DETAIL_SOCKET_SELECT_INTERRUPTER_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_WINDOWS) \
   || defined(__CYGWIN__) \
   || defined(__SYMBIAN32__)
 
 #include <boost/asio/detail/socket_types.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 class socket_select_interrupter
 {
 public:
   // Constructor.
   BOOST_ASIO_DECL socket_select_interrupter();
 
   // Destructor.
   BOOST_ASIO_DECL ~socket_select_interrupter();
 
-  // Recreate the interrupter's descriptors. Used after a fork.
-  BOOST_ASIO_DECL void recreate();
-
   // Interrupt the select call.
   BOOST_ASIO_DECL void interrupt();
 
   // Reset the select interrupt. Returns true if the call was interrupted.
   BOOST_ASIO_DECL bool reset();
 
   // Get the read descriptor to be passed to select.
   socket_type read_descriptor() const
   {
     return read_descriptor_;
   }
 
 private:
-  // Open the descriptors. Throws on error.
-  BOOST_ASIO_DECL void open_descriptors();
-
-  // Close the descriptors.
-  BOOST_ASIO_DECL void close_descriptors();
-
   // The read end of a connection used to interrupt the select call. This file
   // descriptor is passed to select such that when it is time to stop, a single
   // byte will be written on the other end of the connection and this
   // descriptor will become readable.
   socket_type read_descriptor_;
 
   // The write end of a connection used to interrupt the select call. A single
   // byte may be written to this to wake up the select which is waiting for the
   // other end to become readable.
   socket_type write_descriptor_;
 };
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #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)
        // || defined(__CYGWIN__)
        // || defined(__SYMBIAN32__)
 
 #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..f0679b6 100644
--- a/3rdParty/Boost/src/boost/asio/detail/socket_types.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/socket_types.hpp
@@ -1,40 +1,40 @@
 //
 // detail/socket_types.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_SOCKET_TYPES_HPP
 #define BOOST_ASIO_DETAIL_SOCKET_TYPES_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_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__)
 # 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
 # endif // defined(BOOST_ASIO_WSPIAPI_H_DEFINED)
 # if !defined(BOOST_ASIO_NO_DEFAULT_LINKED_LIBS)
 #  if defined(UNDER_CE)
 #   pragma comment(lib, "ws2.lib")
@@ -81,98 +81,96 @@ namespace boost {
 namespace asio {
 namespace detail {
 
 #if defined(BOOST_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;
 typedef in_addr in4_addr_type;
 typedef ip_mreq in4_mreq_type;
 typedef sockaddr_in sockaddr_in4_type;
 # if defined(BOOST_ASIO_HAS_OLD_WIN_SDK)
 typedef in6_addr_emulation in6_addr_type;
 typedef ipv6_mreq_emulation in6_mreq_type;
 typedef sockaddr_in6_emulation sockaddr_in6_type;
 typedef sockaddr_storage_emulation sockaddr_storage_type;
 typedef addrinfo_emulation addrinfo_type;
 # else
 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 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.
 # if defined (_WIN32_WINNT)
 const int max_iov_len = 64;
 # else
 const int max_iov_len = 16;
 # endif
 #else
 typedef int socket_type;
 const int invalid_socket = -1;
 const int socket_error_retval = -1;
 const int max_addr_v4_str_len = INET_ADDRSTRLEN;
 #if defined(INET6_ADDRSTRLEN)
 const int max_addr_v6_str_len = INET6_ADDRSTRLEN + 1 + IF_NAMESIZE;
 #else // defined(INET6_ADDRSTRLEN)
 const int max_addr_v6_str_len = 256;
 #endif // defined(INET6_ADDRSTRLEN)
 typedef sockaddr socket_addr_type;
 typedef in_addr in4_addr_type;
 # if defined(__hpux)
 // HP-UX doesn't provide ip_mreq when _XOPEN_SOURCE_EXTENDED is defined.
 struct in4_mreq_type
 {
   struct in_addr imr_multiaddr;
   struct in_addr imr_interface;
 };
 # else
 typedef ip_mreq in4_mreq_type;
 # endif
 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 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(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
 #endif
 const int custom_socket_option_level = 0xA5100000;
 const int enable_connection_aborted_option = 1;
 const int always_fail_option = 2;
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // BOOST_ASIO_DETAIL_SOCKET_TYPES_HPP
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..0b117ad 100644
--- a/3rdParty/Boost/src/boost/asio/detail/solaris_fenced_block.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/solaris_fenced_block.hpp
@@ -1,63 +1,55 @@
 //
 // detail/solaris_fenced_block.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_SOLARIS_FENCED_BLOCK_HPP
 #define BOOST_ASIO_DETAIL_SOLARIS_FENCED_BLOCK_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(__sun)
 
 #include <atomic.h>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 class solaris_fenced_block
   : private noncopyable
 {
 public:
-  enum half_t { half };
-  enum full_t { full };
-
-  // Constructor for a half fenced block.
-  explicit solaris_fenced_block(half_t)
-  {
-  }
-
-  // Constructor for a full fenced block.
-  explicit solaris_fenced_block(full_t)
+  // Constructor.
+  solaris_fenced_block()
   {
     membar_consumer();
   }
 
   // Destructor.
   ~solaris_fenced_block()
   {
     membar_producer();
   }
 };
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // defined(__sun)
 
 #endif // 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
deleted file mode 100644
index fbac3ed..0000000
--- a/3rdParty/Boost/src/boost/asio/detail/static_mutex.hpp
+++ /dev/null
@@ -1,49 +0,0 @@
-//
-// detail/static_mutex.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_STATIC_MUTEX_HPP
-#define BOOST_ASIO_DETAIL_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_HAS_THREADS) || defined(BOOST_ASIO_DISABLE_THREADS)
-# include <boost/asio/detail/null_static_mutex.hpp>
-#elif defined(BOOST_WINDOWS)
-# include <boost/asio/detail/win_static_mutex.hpp>
-#elif defined(BOOST_HAS_PTHREADS)
-# include <boost/asio/detail/posix_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)
-typedef null_static_mutex static_mutex;
-# define BOOST_ASIO_STATIC_MUTEX_INIT BOOST_ASIO_NULL_STATIC_MUTEX_INIT
-#elif defined(BOOST_WINDOWS)
-typedef win_static_mutex static_mutex;
-# define BOOST_ASIO_STATIC_MUTEX_INIT BOOST_ASIO_WIN_STATIC_MUTEX_INIT
-#elif defined(BOOST_HAS_PTHREADS)
-typedef posix_static_mutex static_mutex;
-# define BOOST_ASIO_STATIC_MUTEX_INIT BOOST_ASIO_POSIX_STATIC_MUTEX_INIT
-#endif
-
-} // namespace detail
-} // namespace asio
-} // namespace boost
-
-#endif // BOOST_ASIO_DETAIL_STATIC_MUTEX_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..0783ac4 100644
--- a/3rdParty/Boost/src/boost/asio/detail/strand_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/strand_service.hpp
@@ -1,139 +1,122 @@
 //
 // detail/strand_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_STRAND_SERVICE_HPP
 #define BOOST_ASIO_DETAIL_STRAND_SERVICE_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/scoped_ptr.hpp>
 #include <boost/asio/io_service.hpp>
 #include <boost/asio/detail/mutex.hpp>
 #include <boost/asio/detail/op_queue.hpp>
 #include <boost/asio/detail/operation.hpp>
-#include <boost/asio/detail/scoped_ptr.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 // Default service implementation for a strand.
 class strand_service
   : public boost::asio::detail::service_base<strand_service>
 {
 private:
   // Helper class to re-post the strand on exit.
   struct on_do_complete_exit;
 
   // Helper class to re-post the strand on exit.
   struct on_dispatch_exit;
 
 public:
 
   // The underlying implementation of a strand.
   class strand_impl
     : public operation
   {
   public:
     strand_impl();
 
   private:
     // Only this service will have access to the internal values.
     friend class strand_service;
     friend struct on_do_complete_exit;
     friend struct on_dispatch_exit;
 
     // Mutex to protect access to internal data.
     boost::asio::detail::mutex mutex_;
 
-    // Indicates whether the strand is currently "locked" by a handler. This
-    // means that there is a handler upcall in progress, or that the strand
-    // itself has been scheduled in order to invoke some pending handlers.
-    bool locked_;
+    // The count of handlers in the strand, including the upcall (if any).
+    std::size_t count_;
 
-    // The handlers that are waiting on the strand but should not be run until
-    // after the next time the strand is scheduled. This queue must only be
-    // modified while the mutex is locked.
-    op_queue<operation> waiting_queue_;
-
-    // The handlers that are ready to be run. Logically speaking, these are the
-    // handlers that hold the strand's lock. The ready queue is only modified
-    // from within the strand and so may be accessed without locking the mutex.
-    op_queue<operation> ready_queue_;
+    // The handlers waiting on the strand.
+    op_queue<operation> queue_;
   };
 
   typedef strand_impl* implementation_type;
 
   // Construct a new strand service for the specified io_service.
   BOOST_ASIO_DECL explicit strand_service(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 strand implementation.
   BOOST_ASIO_DECL void construct(implementation_type& impl);
 
+  // Destroy a strand implementation.
+  void destroy(implementation_type& impl);
+
   // Request the io_service to invoke the given handler.
   template <typename 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);
 
 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 static void do_complete(io_service_impl* owner,
-      operation* base, const boost::system::error_code& ec,
+      operation* base, boost::system::error_code ec,
       std::size_t bytes_transferred);
 
   // The io_service implementation used to post completions.
   io_service_impl& io_service_;
 
   // Mutex to protect access to the array of implementations.
   boost::asio::detail::mutex mutex_;
 
   // Number of implementations shared between all strand objects.
-#if defined(BOOST_ASIO_STRAND_IMPLEMENTATIONS)
-  enum { num_implementations = BOOST_ASIO_STRAND_IMPLEMENTATIONS };
-#else // defined(BOOST_ASIO_STRAND_IMPLEMENTATIONS)
   enum { num_implementations = 193 };
-#endif // defined(BOOST_ASIO_STRAND_IMPLEMENTATIONS)
 
-  // Pool of implementations.
-  scoped_ptr<strand_impl> implementations_[num_implementations];
+  // The head of a linked list of all implementations.
+  boost::scoped_ptr<strand_impl> implementations_[num_implementations];
 
   // Extra value used when hashing to prevent recycled memory locations from
   // getting the same strand implementation.
   std::size_t salt_;
 };
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #include <boost/asio/detail/impl/strand_service.hpp>
 #if defined(BOOST_ASIO_HEADER_ONLY)
 # include <boost/asio/detail/impl/strand_service.ipp>
 #endif // defined(BOOST_ASIO_HEADER_ONLY)
 
 #endif // BOOST_ASIO_DETAIL_STRAND_SERVICE_HPP
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..c014855 100644
--- a/3rdParty/Boost/src/boost/asio/detail/task_io_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/task_io_service.hpp
@@ -1,222 +1,178 @@
 //
 // detail/task_io_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_TASK_IO_SERVICE_HPP
 #define BOOST_ASIO_DETAIL_TASK_IO_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_HAS_IOCP)
 
+#include <boost/detail/atomic_count.hpp>
 #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/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 {
 
 class task_io_service
   : public boost::asio::detail::service_base<task_io_service>
 {
 public:
   typedef task_io_service_operation operation;
 
-  // Constructor. Specifies the number of concurrent threads that are likely to
-  // run the io_service. If set to 1 certain optimisation are performed.
-  BOOST_ASIO_DECL task_io_service(boost::asio::io_service& io_service,
-      std::size_t concurrency_hint = 0);
+  // Constructor.
+  BOOST_ASIO_DECL task_io_service(boost::asio::io_service& io_service);
+
+  // How many concurrent threads are likely to run the io_service.
+  BOOST_ASIO_DECL void init(std::size_t concurrency_hint);
 
   // Destroy all user-defined handler objects owned by the service.
   BOOST_ASIO_DECL void shutdown_service();
 
   // Initialise the task, if required.
   BOOST_ASIO_DECL void init_task();
 
   // Run the event loop until interrupted or no more work.
   BOOST_ASIO_DECL std::size_t run(boost::system::error_code& ec);
 
   // Run until interrupted or one operation is performed.
   BOOST_ASIO_DECL std::size_t run_one(boost::system::error_code& ec);
 
   // Poll for operations without blocking.
   BOOST_ASIO_DECL std::size_t poll(boost::system::error_code& ec);
 
   // Poll for one operation without blocking.
   BOOST_ASIO_DECL std::size_t poll_one(boost::system::error_code& ec);
 
   // Interrupt the event processing loop.
   BOOST_ASIO_DECL void stop();
 
-  // Determine whether the io_service is stopped.
-  BOOST_ASIO_DECL bool stopped() const;
-
   // Reset in preparation for a subsequent run invocation.
   BOOST_ASIO_DECL void reset();
 
   // Notify that some work has started.
   void work_started()
   {
     ++outstanding_work_;
   }
 
   // Notify that some work has finished.
   void work_finished()
   {
     if (--outstanding_work_ == 0)
       stop();
   }
 
-  // Return whether a handler can be dispatched immediately.
-  bool can_dispatch()
-  {
-    return thread_call_stack::contains(this) != 0;
-  }
-
   // Request invocation of the given handler.
   template <typename Handler>
   void dispatch(Handler handler);
 
   // Request invocation of the given handler and return immediately.
   template <typename 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);
 
   // 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);
-
-  // 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);
+  struct idle_thread_info;
 
-  // 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);
+  // Run at most one operation. Blocks only if this_idle_thread is non-null.
+  BOOST_ASIO_DECL std::size_t do_one(mutex::scoped_lock& lock,
+      idle_thread_info* this_idle_thread);
 
   // 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;
   friend struct task_cleanup;
 
-  // Helper class to call work-related operations on block exit.
-  struct work_cleanup;
-  friend struct work_cleanup;
-
-  // Whether to optimise for single-threaded use cases.
-  const bool one_thread_;
+  // Helper class to call work_finished() on block exit.
+  struct work_finished_on_block_exit;
 
   // Mutex to protect access to internal data.
-  mutable mutex mutex_;
+  mutex mutex_;
 
   // 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
   {
     task_operation() : operation(0) {}
   } task_operation_;
 
   // Whether the task has been interrupted.
   bool task_interrupted_;
 
   // The count of unfinished work.
-  atomic_count outstanding_work_;
+  boost::detail::atomic_count outstanding_work_;
 
   // The queue of handlers that are ready to be delivered.
   op_queue<operation> op_queue_;
 
   // Flag to indicate that the dispatcher has been stopped.
   bool stopped_;
 
   // 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_;
+  idle_thread_info* first_idle_thread_;
 };
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #include <boost/asio/detail/impl/task_io_service.hpp>
 #if defined(BOOST_ASIO_HEADER_ONLY)
 # include <boost/asio/detail/impl/task_io_service.ipp>
 #endif // defined(BOOST_ASIO_HEADER_ONLY)
 
 #endif // !defined(BOOST_ASIO_HAS_IOCP)
 
 #endif // BOOST_ASIO_DETAIL_TASK_IO_SERVICE_HPP
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
index 4aa0ec3..b3243b7 100644
--- a/3rdParty/Boost/src/boost/asio/detail/task_io_service_fwd.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/task_io_service_fwd.hpp
@@ -1,28 +1,28 @@
 //
 // detail/task_io_service_fwd.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_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..08164fa 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,77 +1,71 @@
 //
 // detail/task_io_service_operation.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_TASK_IO_SERVICE_OPERATION_HPP
 #define BOOST_ASIO_DETAIL_TASK_IO_SERVICE_OPERATION_HPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # 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 {
 
 // 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
+class task_io_service_operation
 {
 public:
-  void complete(task_io_service& owner,
-      const boost::system::error_code& ec, std::size_t bytes_transferred)
+  void complete(task_io_service& owner)
   {
-    func_(&owner, this, ec, bytes_transferred);
+    func_(&owner, this, boost::system::error_code(), 0);
   }
 
   void destroy()
   {
     func_(0, this, boost::system::error_code(), 0);
   }
 
 protected:
   typedef void (*func_type)(task_io_service*,
       task_io_service_operation*,
-      const boost::system::error_code&, std::size_t);
+      boost::system::error_code, std::size_t);
 
   task_io_service_operation(func_type func)
     : next_(0),
-      func_(func),
-      task_result_(0)
+      func_(func)
   {
   }
 
   // Prevents deletion through this type.
   ~task_io_service_operation()
   {
   }
 
 private:
   friend class op_queue_access;
   task_io_service_operation* next_;
   func_type func_;
-protected:
-  friend class task_io_service;
-  unsigned int task_result_; // Passed into bytes transferred.
 };
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // BOOST_ASIO_DETAIL_TASK_IO_SERVICE_OPERATION_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/thread.hpp b/3rdParty/Boost/src/boost/asio/detail/thread.hpp
index 5b452cf..48cffb1 100644
--- a/3rdParty/Boost/src/boost/asio/detail/thread.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/thread.hpp
@@ -1,40 +1,40 @@
 //
 // detail/thread.hpp
 // ~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_THREAD_HPP
 #define BOOST_ASIO_DETAIL_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_HAS_THREADS) || defined(BOOST_ASIO_DISABLE_THREADS)
 # include <boost/asio/detail/null_thread.hpp>
 #elif defined(BOOST_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)
 # include <boost/asio/detail/posix_thread.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)
 typedef null_thread thread;
 #elif defined(BOOST_WINDOWS)
diff --git a/3rdParty/Boost/src/boost/asio/detail/throw_error.hpp b/3rdParty/Boost/src/boost/asio/detail/throw_error.hpp
index bfb545a..43bc9c3 100644
--- a/3rdParty/Boost/src/boost/asio/detail/throw_error.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/throw_error.hpp
@@ -1,40 +1,40 @@
 //
 // detail/throw_error.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_THROW_ERROR_HPP
 #define BOOST_ASIO_DETAIL_THROW_ERROR_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/system/error_code.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 BOOST_ASIO_DECL void do_throw_error(const boost::system::error_code& err);
 
 BOOST_ASIO_DECL void do_throw_error(const boost::system::error_code& err,
     const char* location);
 
 inline void throw_error(const boost::system::error_code& err)
 {
   if (err)
     do_throw_error(err);
 }
 
 inline void throw_error(const boost::system::error_code& err,
     const char* location)
 {
diff --git a/3rdParty/Boost/src/boost/asio/detail/wait_op.hpp b/3rdParty/Boost/src/boost/asio/detail/timer_op.hpp
index 0209eb0..24a536c 100644
--- a/3rdParty/Boost/src/boost/asio/detail/wait_op.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/timer_op.hpp
@@ -1,47 +1,47 @@
 //
-// detail/wait_op.hpp
-// ~~~~~~~~~~~~~~~~~~
+// detail/timer_op.hpp
+// ~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_WAIT_OP_HPP
-#define BOOST_ASIO_DETAIL_WAIT_OP_HPP
+#ifndef BOOST_ASIO_DETAIL_TIMER_OP_HPP
+#define BOOST_ASIO_DETAIL_TIMER_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 {
 
-class wait_op
+class timer_op
   : public operation
 {
 public:
   // The error code to be passed to the completion handler.
   boost::system::error_code ec_;
 
 protected:
-  wait_op(func_type func)
+  timer_op(func_type func)
     : operation(func)
   {
   }
 };
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
-#endif // BOOST_ASIO_DETAIL_WAIT_OP_HPP
+#endif // BOOST_ASIO_DETAIL_TIMER_OP_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..328a9ed 100644
--- a/3rdParty/Boost/src/boost/asio/detail/timer_queue.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/timer_queue.hpp
@@ -1,223 +1,234 @@
 //
 // detail/timer_queue.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_TIMER_QUEUE_HPP
 #define BOOST_ASIO_DETAIL_TIMER_QUEUE_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 <vector>
 #include <boost/config.hpp>
 #include <boost/limits.hpp>
-#include <boost/cstdint.hpp>
-#include <boost/asio/detail/date_time_fwd.hpp>
 #include <boost/asio/detail/op_queue.hpp>
+#include <boost/asio/detail/timer_op.hpp>
 #include <boost/asio/detail/timer_queue_base.hpp>
-#include <boost/asio/detail/wait_op.hpp>
 #include <boost/asio/error.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>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 template <typename Time_Traits>
 class timer_queue
   : public timer_queue_base
 {
 public:
   // The time type.
   typedef typename Time_Traits::time_type time_type;
 
   // The duration type.
   typedef typename Time_Traits::duration_type duration_type;
 
   // Per-timer data.
   class per_timer_data
   {
   public:
     per_timer_data() : next_(0), prev_(0) {}
 
   private:
     friend class timer_queue;
 
     // The operations waiting on the timer.
-    op_queue<wait_op> op_queue_;
+    op_queue<timer_op> op_queue_;
 
     // The index of the timer in the heap.
     std::size_t heap_index_;
 
     // Pointers to adjacent timers in a linked list.
     per_timer_data* next_;
     per_timer_data* prev_;
   };
 
   // Constructor.
   timer_queue()
     : timers_(),
       heap_()
   {
   }
 
   // Add a new timer to the queue. Returns true if this is the timer that is
   // earliest in the queue, in which case the reactor's event demultiplexing
   // function call may need to be interrupted and restarted.
-  bool enqueue_timer(const time_type& time, per_timer_data& timer, wait_op* op)
+  bool enqueue_timer(const time_type& time, per_timer_data& timer, timer_op* op)
   {
     // Enqueue the timer object.
     if (timer.prev_ == 0 && &timer != timers_)
     {
       if (this->is_positive_infinity(time))
       {
         // No heap entry is required for timers that never expire.
         timer.heap_index_ = (std::numeric_limits<std::size_t>::max)();
       }
       else
       {
         // Put the new timer at the correct position in the heap. This is done
         // first since push_back() can throw due to allocation failure.
         timer.heap_index_ = heap_.size();
         heap_entry entry = { time, &timer };
         heap_.push_back(entry);
         up_heap(heap_.size() - 1);
       }
 
       // Insert the new timer into the linked list of active timers.
       timer.next_ = timers_;
       timer.prev_ = 0;
       if (timers_)
         timers_->prev_ = &timer;
       timers_ = &timer;
     }
 
     // Enqueue the individual timer operation.
     timer.op_queue_.push(op);
 
     // Interrupt reactor only if newly added timer is first to expire.
     return timer.heap_index_ == 0 && timer.op_queue_.front() == op;
   }
 
   // Whether there are no timers in the queue.
   virtual bool empty() const
   {
     return timers_ == 0;
   }
 
   // Get the time for the timer that is earliest in the queue.
   virtual long wait_duration_msec(long max_duration) const
   {
     if (heap_.empty())
       return max_duration;
 
-    return this->to_msec(
-        Time_Traits::to_posix_duration(
-          Time_Traits::subtract(heap_[0].time_, Time_Traits::now())),
-        max_duration);
+    boost::posix_time::time_duration duration = Time_Traits::to_posix_duration(
+        Time_Traits::subtract(heap_[0].time_, Time_Traits::now()));
+
+    if (duration > boost::posix_time::milliseconds(max_duration))
+      duration = boost::posix_time::milliseconds(max_duration);
+    else if (duration <= boost::posix_time::milliseconds(0))
+      duration = boost::posix_time::milliseconds(0);
+    else if (duration < boost::posix_time::milliseconds(1))
+      duration = boost::posix_time::milliseconds(1);
+
+    return duration.total_milliseconds();
   }
 
   // Get the time for the timer that is earliest in the queue.
   virtual long wait_duration_usec(long max_duration) const
   {
     if (heap_.empty())
       return max_duration;
 
-    return this->to_usec(
-        Time_Traits::to_posix_duration(
-          Time_Traits::subtract(heap_[0].time_, Time_Traits::now())),
-        max_duration);
+    boost::posix_time::time_duration duration = Time_Traits::to_posix_duration(
+        Time_Traits::subtract(heap_[0].time_, Time_Traits::now()));
+
+    if (duration > boost::posix_time::microseconds(max_duration))
+      duration = boost::posix_time::microseconds(max_duration);
+    else if (duration <= boost::posix_time::microseconds(0))
+      duration = boost::posix_time::microseconds(0);
+    else if (duration < boost::posix_time::microseconds(1))
+      duration = boost::posix_time::microseconds(1);
+
+    return duration.total_microseconds();
   }
 
   // Dequeue all timers not later than the current time.
   virtual void get_ready_timers(op_queue<operation>& ops)
   {
-    if (!heap_.empty())
+    const time_type now = Time_Traits::now();
+    while (!heap_.empty() && !Time_Traits::less_than(now, heap_[0].time_))
     {
-      const time_type now = Time_Traits::now();
-      while (!heap_.empty() && !Time_Traits::less_than(now, heap_[0].time_))
-      {
-        per_timer_data* timer = heap_[0].timer_;
-        ops.push(timer->op_queue_);
-        remove_timer(*timer);
-      }
+      per_timer_data* timer = heap_[0].timer_;
+      ops.push(timer->op_queue_);
+      remove_timer(*timer);
     }
   }
 
   // Dequeue all timers.
   virtual void get_all_timers(op_queue<operation>& ops)
   {
     while (timers_)
     {
       per_timer_data* timer = timers_;
       timers_ = timers_->next_;
       ops.push(timer->op_queue_);
       timer->next_ = 0;
       timer->prev_ = 0;
     }
 
     heap_.clear();
   }
 
-  // Cancel and dequeue operations for the given timer.
-  std::size_t cancel_timer(per_timer_data& timer, op_queue<operation>& ops,
-      std::size_t max_cancelled = (std::numeric_limits<std::size_t>::max)())
+  // Cancel and dequeue the timers with the given token.
+  std::size_t cancel_timer(per_timer_data& timer, op_queue<operation>& ops)
   {
     std::size_t num_cancelled = 0;
     if (timer.prev_ != 0 || &timer == timers_)
     {
-      while (wait_op* op = (num_cancelled != max_cancelled)
-          ? timer.op_queue_.front() : 0)
+      while (timer_op* op = timer.op_queue_.front())
       {
         op->ec_ = boost::asio::error::operation_aborted;
         timer.op_queue_.pop();
         ops.push(op);
         ++num_cancelled;
       }
-      if (timer.op_queue_.empty())
-        remove_timer(timer);
+      remove_timer(timer);
     }
     return num_cancelled;
   }
 
 private:
   // Move the item at the given index up the heap to its correct position.
   void up_heap(std::size_t index)
   {
     std::size_t parent = (index - 1) / 2;
     while (index > 0
         && Time_Traits::less_than(heap_[index].time_, heap_[parent].time_))
     {
       swap_heap(index, parent);
       index = parent;
       parent = (index - 1) / 2;
     }
   }
 
   // Move the item at the given index down the heap to its correct position.
   void down_heap(std::size_t index)
   {
     std::size_t child = index * 2 + 1;
     while (child < heap_.size())
     {
       std::size_t min_child = (child + 1 == heap_.size()
           || Time_Traits::less_than(
             heap_[child].time_, heap_[child + 1].time_))
         ? child : child + 1;
       if (Time_Traits::less_than(heap_[index].time_, heap_[min_child].time_))
         break;
       swap_heap(index, min_child);
       index = min_child;
       child = index * 2 + 1;
     }
   }
@@ -243,93 +254,120 @@ private:
       {
         heap_.pop_back();
       }
       else
       {
         swap_heap(index, heap_.size() - 1);
         heap_.pop_back();
         std::size_t parent = (index - 1) / 2;
         if (index > 0 && Time_Traits::less_than(
               heap_[index].time_, heap_[parent].time_))
           up_heap(index);
         else
           down_heap(index);
       }
     }
 
     // Remove the timer from the linked list of active timers.
     if (timers_ == &timer)
       timers_ = timer.next_;
     if (timer.prev_)
       timer.prev_->next_ = timer.next_;
     if (timer.next_)
       timer.next_->prev_= timer.prev_;
     timer.next_ = 0;
     timer.prev_ = 0;
   }
 
   // Determine if the specified absolute time is positive infinity.
   template <typename Time_Type>
   static bool is_positive_infinity(const Time_Type&)
   {
     return false;
   }
 
   // Determine if the specified absolute time is positive infinity.
-  template <typename T, typename TimeSystem>
-  static bool is_positive_infinity(
-      const boost::date_time::base_time<T, TimeSystem>& time)
-  {
-    return time.is_pos_infinity();
-  }
-
-  // Helper function to convert a duration into milliseconds.
-  template <typename Duration>
-  long to_msec(const Duration& d, long max_duration) const
+  static bool is_positive_infinity(const boost::posix_time::ptime& time)
   {
-    if (d.ticks() <= 0)
-      return 0;
-    boost::int64_t msec = d.total_milliseconds();
-    if (msec == 0)
-      return 1;
-    if (msec > max_duration)
-      return max_duration;
-    return static_cast<long>(msec);
-  }
-
-  // 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();
-    if (usec == 0)
-      return 1;
-    if (usec > max_duration)
-      return max_duration;
-    return static_cast<long>(usec);
+    return time == boost::posix_time::pos_infin;
   }
 
   // The head of a linked list of all active timers.
   per_timer_data* timers_;
 
   struct heap_entry
   {
     // The time when the timer should fire.
     time_type time_;
 
     // The associated timer with enqueued operations.
     per_timer_data* timer_;
   };
 
   // The heap of timers, with the earliest timer at the front.
   std::vector<heap_entry> heap_;
 };
 
+#if !defined(BOOST_ASIO_HEADER_ONLY)
+
+struct forwarding_posix_time_traits : time_traits<boost::posix_time::ptime> {};
+
+// Template specialisation for the commonly used instantation.
+template <>
+class timer_queue<time_traits<boost::posix_time::ptime> >
+  : public timer_queue_base
+{
+public:
+  // The time type.
+  typedef boost::posix_time::ptime time_type;
+
+  // The duration type.
+  typedef boost::posix_time::time_duration duration_type;
+
+  // Per-timer data.
+  typedef timer_queue<forwarding_posix_time_traits>::per_timer_data
+    per_timer_data;
+
+  // Constructor.
+  BOOST_ASIO_DECL timer_queue();
+
+  // Destructor.
+  BOOST_ASIO_DECL virtual ~timer_queue();
+
+  // Add a new timer to the queue. Returns true if this is the timer that is
+  // earliest in the queue, in which case the reactor's event demultiplexing
+  // function call may need to be interrupted and restarted.
+  BOOST_ASIO_DECL bool enqueue_timer(const time_type& time,
+      per_timer_data& timer, timer_op* op);
+
+  // Whether there are no timers in the queue.
+  BOOST_ASIO_DECL virtual bool empty() const;
+
+  // Get the time for the timer that is earliest in the queue.
+  BOOST_ASIO_DECL virtual long wait_duration_msec(long max_duration) const;
+
+  // Get the time for the timer that is earliest in the queue.
+  BOOST_ASIO_DECL virtual long wait_duration_usec(long max_duration) const;
+
+  // Dequeue all timers not later than the current time.
+  BOOST_ASIO_DECL virtual void get_ready_timers(op_queue<operation>& ops);
+
+  // Dequeue all timers.
+  BOOST_ASIO_DECL virtual void get_all_timers(op_queue<operation>& ops);
+
+  // Cancel and dequeue the timers with the given token.
+  BOOST_ASIO_DECL std::size_t cancel_timer(
+      per_timer_data& timer, op_queue<operation>& ops);
+
+private:
+  timer_queue<forwarding_posix_time_traits> impl_;
+};
+
+#endif // !defined(BOOST_ASIO_HEADER_ONLY)
+
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // BOOST_ASIO_DETAIL_TIMER_QUEUE_HPP
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..d493871 100644
--- a/3rdParty/Boost/src/boost/asio/detail/timer_queue_base.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/timer_queue_base.hpp
@@ -1,40 +1,40 @@
 //
 // detail/timer_queue_base.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_TIMER_QUEUE_BASE_HPP
 #define BOOST_ASIO_DETAIL_TIMER_QUEUE_BASE_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/noncopyable.hpp>
 #include <boost/asio/detail/op_queue.hpp>
 #include <boost/asio/detail/operation.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 class timer_queue_base
   : private noncopyable
 {
 public:
   // Constructor.
   timer_queue_base() : next_(0) {}
 
   // Destructor.
   virtual ~timer_queue_base() {}
 
   // Whether there are no timers in the queue.
   virtual bool empty() const = 0;
diff --git a/3rdParty/Boost/src/boost/asio/detail/timer_queue_fwd.hpp b/3rdParty/Boost/src/boost/asio/detail/timer_queue_fwd.hpp
index c97753f..14c6319 100644
--- a/3rdParty/Boost/src/boost/asio/detail/timer_queue_fwd.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/timer_queue_fwd.hpp
@@ -1,29 +1,29 @@
 //
 // detail/timer_queue_fwd.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_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
deleted file mode 100644
index 4c32ece..0000000
--- a/3rdParty/Boost/src/boost/asio/detail/timer_queue_ptime.hpp
+++ /dev/null
@@ -1,91 +0,0 @@
-//
-// detail/timer_queue_ptime.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_PTIME_HPP
-#define BOOST_ASIO_DETAIL_TIMER_QUEUE_PTIME_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include <boost/asio/time_traits.hpp>
-#include <boost/asio/detail/timer_queue.hpp>
-
-#include <boost/asio/detail/push_options.hpp>
-
-namespace boost {
-namespace asio {
-namespace detail {
-
-struct forwarding_posix_time_traits : time_traits<boost::posix_time::ptime> {};
-
-// Template specialisation for the commonly used instantation.
-template <>
-class timer_queue<time_traits<boost::posix_time::ptime> >
-  : public timer_queue_base
-{
-public:
-  // The time type.
-  typedef boost::posix_time::ptime time_type;
-
-  // The duration type.
-  typedef boost::posix_time::time_duration duration_type;
-
-  // Per-timer data.
-  typedef timer_queue<forwarding_posix_time_traits>::per_timer_data
-    per_timer_data;
-
-  // Constructor.
-  BOOST_ASIO_DECL timer_queue();
-
-  // Destructor.
-  BOOST_ASIO_DECL virtual ~timer_queue();
-
-  // Add a new timer to the queue. Returns true if this is the timer that is
-  // earliest in the queue, in which case the reactor's event demultiplexing
-  // function call may need to be interrupted and restarted.
-  BOOST_ASIO_DECL bool enqueue_timer(const time_type& time,
-      per_timer_data& timer, wait_op* op);
-
-  // Whether there are no timers in the queue.
-  BOOST_ASIO_DECL virtual bool empty() const;
-
-  // Get the time for the timer that is earliest in the queue.
-  BOOST_ASIO_DECL virtual long wait_duration_msec(long max_duration) const;
-
-  // Get the time for the timer that is earliest in the queue.
-  BOOST_ASIO_DECL virtual long wait_duration_usec(long max_duration) const;
-
-  // Dequeue all timers not later than the current time.
-  BOOST_ASIO_DECL virtual void get_ready_timers(op_queue<operation>& ops);
-
-  // Dequeue all timers.
-  BOOST_ASIO_DECL virtual void get_all_timers(op_queue<operation>& ops);
-
-  // Cancel and dequeue operations for the given timer.
-  BOOST_ASIO_DECL std::size_t cancel_timer(
-      per_timer_data& timer, op_queue<operation>& ops,
-      std::size_t max_cancelled = (std::numeric_limits<std::size_t>::max)());
-
-private:
-  timer_queue<forwarding_posix_time_traits> impl_;
-};
-
-} // namespace detail
-} // namespace asio
-} // namespace boost
-
-#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)
-
-#endif // BOOST_ASIO_DETAIL_TIMER_QUEUE_PTIME_HPP
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..549d7e6 100644
--- a/3rdParty/Boost/src/boost/asio/detail/timer_queue_set.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/timer_queue_set.hpp
@@ -1,40 +1,40 @@
 //
 // detail/timer_queue_set.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_TIMER_QUEUE_SET_HPP
 #define BOOST_ASIO_DETAIL_TIMER_QUEUE_SET_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/timer_queue_base.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 class timer_queue_set
 {
 public:
   // Constructor.
   BOOST_ASIO_DECL timer_queue_set();
 
   // Add a timer queue to the set.
   BOOST_ASIO_DECL void insert(timer_queue_base* q);
 
   // Remove a timer queue from the set.
   BOOST_ASIO_DECL void erase(timer_queue_base* q);
 
   // Determine whether all queues are empty.
   BOOST_ASIO_DECL bool all_empty() const;
diff --git a/3rdParty/Boost/src/boost/asio/detail/timer_scheduler.hpp b/3rdParty/Boost/src/boost/asio/detail/timer_scheduler.hpp
index 8feea78..2edc0c8 100644
--- a/3rdParty/Boost/src/boost/asio/detail/timer_scheduler.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/timer_scheduler.hpp
@@ -1,33 +1,33 @@
 //
 // detail/timer_scheduler.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_TIMER_SCHEDULER_HPP
 #define BOOST_ASIO_DETAIL_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>
 #include <boost/asio/detail/timer_scheduler_fwd.hpp>
 
 #if 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)
 # include <boost/asio/detail/dev_poll_reactor.hpp>
 #else
 # include <boost/asio/detail/select_reactor.hpp>
 #endif
 
 #endif // BOOST_ASIO_DETAIL_TIMER_SCHEDULER_HPP
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..e01b657 100644
--- a/3rdParty/Boost/src/boost/asio/detail/timer_scheduler_fwd.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/timer_scheduler_fwd.hpp
@@ -1,40 +1,40 @@
 //
 // detail/timer_scheduler_fwd.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_TIMER_SCHEDULER_FWD_HPP
 #define BOOST_ASIO_DETAIL_TIMER_SCHEDULER_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)
 # 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;
 #elif defined(BOOST_ASIO_HAS_EPOLL)
 typedef epoll_reactor timer_scheduler;
 #elif defined(BOOST_ASIO_HAS_KQUEUE)
diff --git a/3rdParty/Boost/src/boost/asio/detail/tss_ptr.hpp b/3rdParty/Boost/src/boost/asio/detail/tss_ptr.hpp
index d14a959..35ed8e2 100644
--- a/3rdParty/Boost/src/boost/asio/detail/tss_ptr.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/tss_ptr.hpp
@@ -1,71 +1,65 @@
 //
 // detail/tss_ptr.hpp
 // ~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_TSS_PTR_HPP
 #define BOOST_ASIO_DETAIL_TSS_PTR_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_HAS_THREADS) || defined(BOOST_ASIO_DISABLE_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)
 # include <boost/asio/detail/win_tss_ptr.hpp>
 #elif defined(BOOST_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>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 template <typename T>
 class tss_ptr
 #if !defined(BOOST_HAS_THREADS) || defined(BOOST_ASIO_DISABLE_THREADS)
   : public null_tss_ptr<T>
-#elif defined(BOOST_ASIO_HAS_THREAD_KEYWORD_EXTENSION)
-  : public keyword_tss_ptr<T>
 #elif defined(BOOST_WINDOWS)
   : public win_tss_ptr<T>
 #elif defined(BOOST_HAS_PTHREADS)
   : public posix_tss_ptr<T>
 #endif
 {
 public:
   void operator=(T* value)
   {
 #if !defined(BOOST_HAS_THREADS) || defined(BOOST_ASIO_DISABLE_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)
     win_tss_ptr<T>::operator=(value);
 #elif defined(BOOST_HAS_PTHREADS)
     posix_tss_ptr<T>::operator=(value);
 #endif
   }
 };
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // BOOST_ASIO_DETAIL_TSS_PTR_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..95be6bd 100644
--- a/3rdParty/Boost/src/boost/asio/detail/wait_handler.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/wait_handler.hpp
@@ -1,84 +1,78 @@
 //
 // detail/wait_handler.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_WAIT_HANDLER_HPP
 #define BOOST_ASIO_DETAIL_WAIT_HANDLER_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/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>
+#include <boost/asio/detail/timer_op.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 template <typename Handler>
-class wait_handler : public wait_op
+class wait_handler : public timer_op
 {
 public:
   BOOST_ASIO_DEFINE_HANDLER_PTR(wait_handler);
 
-  wait_handler(Handler& h)
-    : wait_op(&wait_handler::do_complete),
-      handler_(BOOST_ASIO_MOVE_CAST(Handler)(h))
+  wait_handler(Handler h)
+    : timer_op(&wait_handler::do_complete),
+      handler_(h)
   {
   }
 
   static void do_complete(io_service_impl* owner, operation* base,
-      const boost::system::error_code& /*ec*/,
-      std::size_t /*bytes_transferred*/)
+      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 };
 
-    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.reset();
 
     // Make the upcall if required.
     if (owner)
     {
-      fenced_block b(fenced_block::half);
-      BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_));
+      boost::asio::detail::fenced_block b;
       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 // BOOST_ASIO_DETAIL_WAIT_HANDLER_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..81a8b06 100644
--- a/3rdParty/Boost/src/boost/asio/detail/weak_ptr.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/weak_ptr.hpp
@@ -1,40 +1,41 @@
 //
 // detail/weak_ptr.hpp
 // ~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_WEAK_PTR_HPP
 #define BOOST_ASIO_DETAIL_WEAK_PTR_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/version.hpp>
 
-#if defined(BOOST_ASIO_HAS_STD_SHARED_PTR)
+#if defined(_MSC_VER) && (_MSC_VER >= 1600)
 # include <memory>
-#else // defined(BOOST_ASIO_HAS_STD_SHARED_PTR)
+#else
 # include <boost/weak_ptr.hpp>
-#endif // defined(BOOST_ASIO_HAS_STD_SHARED_PTR)
+#endif
 
 namespace boost {
 namespace asio {
 namespace detail {
 
-#if defined(BOOST_ASIO_HAS_STD_SHARED_PTR)
+#if defined(_MSC_VER) && (_MSC_VER >= 1600)
 using std::weak_ptr;
-#else // defined(BOOST_ASIO_HAS_STD_SHARED_PTR)
+#else
 using boost::weak_ptr;
-#endif // defined(BOOST_ASIO_HAS_STD_SHARED_PTR)
+#endif
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #endif // 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..63c25c4 100644
--- a/3rdParty/Boost/src/boost/asio/detail/win_event.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/win_event.hpp
@@ -1,40 +1,40 @@
 //
 // detail/win_event.hpp
 // ~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_WIN_EVENT_HPP
 #define BOOST_ASIO_DETAIL_WIN_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_WINDOWS)
 
 #include <boost/assert.hpp>
 #include <boost/asio/detail/noncopyable.hpp>
 #include <boost/asio/detail/socket_types.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 class win_event
   : private noncopyable
 {
 public:
   // Constructor.
   BOOST_ASIO_DECL win_event();
 
   // Destructor.
   ~win_event()
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..8636a91 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,125 +1,92 @@
 //
 // detail/win_fd_set_adapter.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_WIN_FD_SET_ADAPTER_HPP
 #define BOOST_ASIO_DETAIL_WIN_FD_SET_ADAPTER_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_WINDOWS) || defined(__CYGWIN__)
 
-#include <boost/asio/detail/noncopyable.hpp>
 #include <boost/asio/detail/socket_types.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 // Adapts the FD_SET type to meet the Descriptor_Set concept's requirements.
-class win_fd_set_adapter : noncopyable
+class win_fd_set_adapter
 {
 public:
-  enum { default_fd_set_size = 1024 };
+  enum { win_fd_set_size = 1024 };
 
   win_fd_set_adapter()
-    : capacity_(default_fd_set_size),
-      max_descriptor_(invalid_socket)
+    : max_descriptor_(invalid_socket)
   {
-    fd_set_ = static_cast<win_fd_set*>(::operator new(
-          sizeof(win_fd_set) - sizeof(SOCKET)
-          + sizeof(SOCKET) * (capacity_)));
-    fd_set_->fd_count = 0;
-  }
-
-  ~win_fd_set_adapter()
-  {
-    ::operator delete(fd_set_);
-  }
-
-  void reset()
-  {
-    fd_set_->fd_count = 0;
-    max_descriptor_ = invalid_socket;
+    fd_set_.fd_count = 0;
   }
 
   bool set(socket_type descriptor)
   {
-    for (u_int i = 0; i < fd_set_->fd_count; ++i)
-      if (fd_set_->fd_array[i] == 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_)
+    if (fd_set_.fd_count < win_fd_set_size)
     {
-      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;
+      fd_set_.fd_array[fd_set_.fd_count++] = descriptor;
+      return true;
     }
-
-    fd_set_->fd_array[fd_set_->fd_count++] = descriptor;
-    return true;
+    return false;
   }
 
   bool is_set(socket_type descriptor) const
   {
     return !!__WSAFDIsSet(descriptor,
-        const_cast<fd_set*>(reinterpret_cast<const fd_set*>(fd_set_)));
+        const_cast<fd_set*>(reinterpret_cast<const fd_set*>(&fd_set_)));
   }
 
   operator fd_set*()
   {
-    return reinterpret_cast<fd_set*>(fd_set_);
+    return reinterpret_cast<fd_set*>(&fd_set_);
   }
 
   socket_type max_descriptor() const
   {
     return max_descriptor_;
   }
 
 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.
+  // structure, but without being dependent on the value of FD_SETSIZE.
   struct win_fd_set
   {
     u_int fd_count;
-    SOCKET fd_array[1];
+    SOCKET fd_array[win_fd_set_size];
   };
 
-  win_fd_set* fd_set_;
-  u_int capacity_;
+  win_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 // 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..769db2e 100644
--- a/3rdParty/Boost/src/boost/asio/detail/win_fenced_block.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/win_fenced_block.hpp
@@ -1,78 +1,70 @@
 //
 // detail/win_fenced_block.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_WIN_FENCED_BLOCK_HPP
 #define BOOST_ASIO_DETAIL_WIN_FENCED_BLOCK_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_WINDOWS) && !defined(UNDER_CE)
 
 #include <boost/asio/detail/socket_types.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 class win_fenced_block
   : private noncopyable
 {
 public:
-  enum half_t { half };
-  enum full_t { full };
-
-  // Constructor for a half fenced block.
-  explicit win_fenced_block(half_t)
-  {
-  }
-
-  // Constructor for a full fenced block.
-  explicit win_fenced_block(full_t)
+  // Constructor.
+  win_fenced_block()
   {
 #if defined(__BORLANDC__)
     LONG barrier = 0;
     ::InterlockedExchange(&barrier, 1);
 #elif defined(BOOST_MSVC) && ((BOOST_MSVC < 1400) || !defined(MemoryBarrier))
 # if defined(_M_IX86)
 #  pragma warning(push)
 #  pragma warning(disable:4793)
     LONG barrier;
     __asm { xchg barrier, eax }
 #  pragma warning(pop)
 # endif // defined(_M_IX86)
 #else
     MemoryBarrier();
 #endif
   }
 
   // Destructor.
   ~win_fenced_block()
   {
 #if defined(__BORLANDC__)
     LONG barrier = 0;
     ::InterlockedExchange(&barrier, 1);
 #elif defined(BOOST_MSVC) && ((BOOST_MSVC < 1400) || !defined(MemoryBarrier))
 # if defined(_M_IX86)
 #  pragma warning(push)
 #  pragma warning(disable:4793)
     LONG barrier;
     __asm { xchg barrier, eax }
 #  pragma warning(pop)
 # endif // defined(_M_IX86)
 #else
     MemoryBarrier();
 #endif
   }
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..5edffa3 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,111 +1,103 @@
 //
 // detail/win_iocp_handle_read_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2011 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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_WIN_IOCP_HANDLE_READ_OP_HPP
 #define BOOST_ASIO_DETAIL_WIN_IOCP_HANDLE_READ_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/error.hpp>
 #include <boost/utility/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>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 template <typename MutableBufferSequence, typename Handler>
 class win_iocp_handle_read_op : public operation
 {
 public:
   BOOST_ASIO_DEFINE_HANDLER_PTR(win_iocp_handle_read_op);
 
-  win_iocp_handle_read_op(
-      const MutableBufferSequence& buffers, Handler& handler)
+  win_iocp_handle_read_op(const MutableBufferSequence& buffers, Handler handler)
     : operation(&win_iocp_handle_read_op::do_complete),
       buffers_(buffers),
-      handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler))
+      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, 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 };
 
-    BOOST_ASIO_HANDLER_COMPLETION((o));
-
 #if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)
     if (owner)
     {
       // Check whether buffers are still valid.
       buffer_sequence_adapter<boost::asio::mutable_buffer,
           MutableBufferSequence>::validate(o->buffers_);
     }
 #endif // defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)
 
     // Map non-portable errors to their portable counterparts.
     if (ec.value() == ERROR_HANDLE_EOF)
       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_, ec, bytes_transferred);
     p.h = boost::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::detail::fenced_block b;
       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_HAS_IOCP)
 
 #endif // BOOST_ASIO_DETAIL_WIN_IOCP_HANDLE_READ_OP_HPP
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..86c4391 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,275 +1,238 @@
 //
 // detail/win_iocp_handle_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2011 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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_WIN_IOCP_HANDLE_SERVICE_HPP
 #define BOOST_ASIO_DETAIL_WIN_IOCP_HANDLE_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_HAS_IOCP)
 
 #include <boost/cstdint.hpp>
 #include <boost/asio/error.hpp>
 #include <boost/asio/io_service.hpp>
 #include <boost/asio/detail/buffer_sequence_adapter.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>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 class win_iocp_handle_service
 {
 public:
   // The native type of a stream handle.
-  typedef HANDLE native_handle_type;
+  typedef HANDLE native_type;
 
   // The implementation type of the stream handle.
   class implementation_type
   {
   public:
     // Default constructor.
     implementation_type()
       : handle_(INVALID_HANDLE_VALUE),
         safe_cancellation_thread_id_(0),
         next_(0),
         prev_(0)
     {
     }
 
   private:
     // Only this service will have access to the internal values.
     friend class win_iocp_handle_service;
 
     // The native stream handle representation.
-    native_handle_type handle_;
+    native_type handle_;
 
     // The ID of the thread from which it is safe to cancel asynchronous
     // operations. 0 means no asynchronous operations have been started yet.
     // ~0 means asynchronous operations have been started from more than one
     // thread, and cancellation is not supported for the handle.
     DWORD safe_cancellation_thread_id_;
 
     // Pointers to adjacent handle implementations in linked list.
     implementation_type* next_;
     implementation_type* prev_;
   };
 
   BOOST_ASIO_DECL win_iocp_handle_service(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 handle implementation.
   BOOST_ASIO_DECL void construct(implementation_type& impl);
 
-  // Move-construct a new handle implementation.
-  BOOST_ASIO_DECL void move_construct(implementation_type& impl,
-      implementation_type& other_impl);
-
-  // Move-assign from another handle implementation.
-  BOOST_ASIO_DECL void move_assign(implementation_type& impl,
-      win_iocp_handle_service& other_service,
-      implementation_type& other_impl);
-
   // Destroy a handle implementation.
   BOOST_ASIO_DECL void destroy(implementation_type& impl);
 
   // Assign a native handle to a handle implementation.
   BOOST_ASIO_DECL boost::system::error_code assign(implementation_type& impl,
-      const native_handle_type& handle, boost::system::error_code& ec);
+      const native_type& native_handle, boost::system::error_code& ec);
 
   // Determine whether the handle is open.
   bool is_open(const implementation_type& impl) const
   {
     return impl.handle_ != INVALID_HANDLE_VALUE;
   }
 
   // Destroy a handle implementation.
   BOOST_ASIO_DECL boost::system::error_code close(implementation_type& impl,
       boost::system::error_code& ec);
 
   // Get the native handle representation.
-  native_handle_type native_handle(const implementation_type& impl) const
+  native_type native(const implementation_type& impl) const
   {
     return impl.handle_;
   }
 
   // Cancel all operations associated with the handle.
   BOOST_ASIO_DECL boost::system::error_code cancel(implementation_type& impl,
       boost::system::error_code& ec);
 
   // Write the given data. Returns the number of bytes written.
   template <typename ConstBufferSequence>
   size_t write_some(implementation_type& impl,
       const ConstBufferSequence& buffers, boost::system::error_code& ec)
   {
     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,
       const ConstBufferSequence& buffers, boost::system::error_code& ec)
   {
     boost::asio::const_buffer buffer =
       buffer_sequence_adapter<boost::asio::const_buffer,
         ConstBufferSequence>::first(buffers);
 
     return do_write(impl, offset, buffer, ec);
   }
 
   // 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)
   {
-    // 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),
-      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"));
-
-    start_write_op(impl, 0,
-        buffer_sequence_adapter<boost::asio::const_buffer,
-          ConstBufferSequence>::first(buffers), p.p);
-    p.v = p.p = 0;
+    async_write_some_at(impl, 0, buffers, handler);
   }
 
   // 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)
   {
     // 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),
       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"));
-
     start_write_op(impl, offset,
         buffer_sequence_adapter<boost::asio::const_buffer,
           ConstBufferSequence>::first(buffers), p.p);
     p.v = p.p = 0;
   }
 
   // Read some data. Returns the number of bytes received.
   template <typename MutableBufferSequence>
   size_t read_some(implementation_type& impl,
       const MutableBufferSequence& buffers, boost::system::error_code& ec)
   {
     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,
       const MutableBufferSequence& buffers, boost::system::error_code& ec)
   {
     boost::asio::mutable_buffer buffer =
       buffer_sequence_adapter<boost::asio::mutable_buffer,
         MutableBufferSequence>::first(buffers);
 
     return do_read(impl, offset, buffer, ec);
   }
 
   // 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)
   {
-    // 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),
-      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"));
-
-    start_read_op(impl, 0,
-        buffer_sequence_adapter<boost::asio::mutable_buffer,
-          MutableBufferSequence>::first(buffers), p.p);
-    p.v = p.p = 0;
+    async_read_some_at(impl, 0, buffers, handler);
   }
 
   // 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)
   {
     // 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),
       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"));
-
     start_read_op(impl, offset,
         buffer_sequence_adapter<boost::asio::mutable_buffer,
           MutableBufferSequence>::first(buffers), p.p);
     p.v = p.p = 0;
   }
 
 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,
       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);
   template <typename Handler>
   void async_write_some_at(implementation_type& impl, boost::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,
       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);
   template <typename Handler>
   void async_read_some_at(implementation_type& impl, boost::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,
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..574dc22 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,103 +1,99 @@
 //
 // detail/win_iocp_handle_write_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2011 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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_WIN_IOCP_HANDLE_WRITE_OP_HPP
 #define BOOST_ASIO_DETAIL_WIN_IOCP_HANDLE_WRITE_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/error.hpp>
 #include <boost/utility/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>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 template <typename ConstBufferSequence, typename Handler>
 class win_iocp_handle_write_op : public operation
 {
 public:
   BOOST_ASIO_DEFINE_HANDLER_PTR(win_iocp_handle_write_op);
 
-  win_iocp_handle_write_op(const ConstBufferSequence& buffers, Handler& handler)
+  win_iocp_handle_write_op(const ConstBufferSequence& buffers, Handler handler)
     : operation(&win_iocp_handle_write_op::do_complete),
       buffers_(buffers),
-      handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler))
+      handler_(handler)
   {
   }
 
   static void do_complete(io_service_impl* owner, operation* base,
-      const boost::system::error_code& ec, std::size_t bytes_transferred)
+      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 };
 
-    BOOST_ASIO_HANDLER_COMPLETION((o));
-
 #if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING)
     if (owner)
     {
       // Check whether buffers are still valid.
       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_, ec, bytes_transferred);
     p.h = boost::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::detail::fenced_block b;
       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_HAS_IOCP)
 
 #endif // BOOST_ASIO_DETAIL_WIN_IOCP_HANDLE_WRITE_OP_HPP
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..4c88e7b 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,303 +1,267 @@
 //
 // detail/win_iocp_io_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_WIN_IOCP_IO_SERVICE_HPP
 #define BOOST_ASIO_DETAIL_WIN_IOCP_IO_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_HAS_IOCP)
 
-#include <boost/limits.hpp>
+#include <boost/scoped_ptr.hpp>
 #include <boost/asio/io_service.hpp>
-#include <boost/asio/detail/call_stack.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_op.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/thread.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
-class wait_op;
+class timer_op;
 
 class win_iocp_io_service
   : public boost::asio::detail::service_base<win_iocp_io_service>
 {
 public:
+  // Constructor.
+  BOOST_ASIO_DECL win_iocp_io_service(boost::asio::io_service& io_service);
 
-  // Constructor. Specifies a concurrency hint that is passed through to the
-  // underlying I/O completion port.
-  BOOST_ASIO_DECL win_iocp_io_service(boost::asio::io_service& io_service,
-      size_t concurrency_hint = 0);
+  BOOST_ASIO_DECL void init(size_t concurrency_hint);
 
   // Destroy all user-defined handler objects owned by the service.
   BOOST_ASIO_DECL void shutdown_service();
 
   // Initialise the task. Nothing to do here.
   void init_task()
   {
   }
 
   // Register a handle with the IO completion port.
   BOOST_ASIO_DECL boost::system::error_code register_handle(
       HANDLE handle, boost::system::error_code& ec);
 
   // Run the event loop until stopped or no more work.
   BOOST_ASIO_DECL size_t run(boost::system::error_code& ec);
 
   // Run until stopped or one operation is performed.
   BOOST_ASIO_DECL size_t run_one(boost::system::error_code& ec);
 
   // Poll for operations without blocking.
   BOOST_ASIO_DECL size_t poll(boost::system::error_code& ec);
 
   // Poll for one operation without blocking.
   BOOST_ASIO_DECL size_t poll_one(boost::system::error_code& ec);
 
   // Stop the event processing loop.
   BOOST_ASIO_DECL void stop();
 
-  // Determine whether the io_service is stopped.
-  bool stopped() const
-  {
-    return ::InterlockedExchangeAdd(&stopped_, 0) != 0;
-  }
-
   // Reset in preparation for a subsequent run invocation.
   void reset()
   {
     ::InterlockedExchange(&stopped_, 0);
   }
 
   // Notify that some work has started.
   void work_started()
   {
     ::InterlockedIncrement(&outstanding_work_);
   }
 
   // Notify that some work has finished.
   void work_finished()
   {
     if (::InterlockedDecrement(&outstanding_work_) == 0)
       stop();
   }
 
-  // Return whether a handler can be dispatched immediately.
-  bool can_dispatch()
-  {
-    return call_stack<win_iocp_io_service>::contains(this) != 0;
-  }
-
   // Request invocation of the given handler.
   template <typename Handler>
   void dispatch(Handler handler);
 
   // Request invocation of the given handler and return immediately.
   template <typename 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)
   {
     work_started();
     post_deferred_completion(op);
   }
 
   // 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(win_iocp_operation* op);
 
   // Request invocation of the given operation and return immediately. Assumes
   // that work_started() was previously called for the operations.
   BOOST_ASIO_DECL void post_deferred_completions(
       op_queue<win_iocp_operation>& ops);
 
-  // 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);
-  }
-
-  // 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)
-  {
-    post_deferred_completion(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);
-
   // Called after starting an overlapped I/O operation that did not complete
   // immediately. The caller must have already called work_started() prior to
   // starting the operation.
   BOOST_ASIO_DECL void on_pending(win_iocp_operation* op);
 
   // Called after starting an overlapped I/O operation that completed
   // immediately. The caller must have already called work_started() prior to
   // starting the operation.
   BOOST_ASIO_DECL void on_completion(win_iocp_operation* op,
       DWORD last_error = 0, DWORD bytes_transferred = 0);
 
   // Called after starting an overlapped I/O operation that completed
   // immediately. The caller must have already called work_started() prior to
   // starting the operation.
   BOOST_ASIO_DECL void on_completion(win_iocp_operation* op,
       const boost::system::error_code& ec, DWORD bytes_transferred = 0);
 
   // Add a new timer queue to the service.
   template <typename Time_Traits>
   void add_timer_queue(timer_queue<Time_Traits>& timer_queue);
 
   // Remove a timer queue from the service.
   template <typename Time_Traits>
   void remove_timer_queue(timer_queue<Time_Traits>& timer_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);
+      typename timer_queue<Time_Traits>::per_timer_data& timer, timer_op* op);
 
   // Cancel the timer associated with the given token. Returns the number of
   // handlers 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)());
+      typename timer_queue<Time_Traits>::per_timer_data& timer);
 
 private:
 #if defined(WINVER) && (WINVER < 0x0500)
   typedef DWORD dword_ptr_t;
   typedef ULONG ulong_ptr_t;
 #else // defined(WINVER) && (WINVER < 0x0500)
   typedef DWORD_PTR dword_ptr_t;
   typedef ULONG_PTR ulong_ptr_t;
 #endif // defined(WINVER) && (WINVER < 0x0500)
 
   // 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 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);
 
   // Called to recalculate and update the timeout.
   BOOST_ASIO_DECL void update_timeout();
 
   // Helper class to call work_finished() on block exit.
   struct work_finished_on_block_exit;
 
   // Helper class for managing a HANDLE.
   struct auto_handle
   {
     HANDLE handle;
     auto_handle() : handle(0) {}
     ~auto_handle() { if (handle) ::CloseHandle(handle); }
   };
 
   // The IO completion port used for queueing operations.
   auto_handle iocp_;
 
   // The count of unfinished work.
   long outstanding_work_;
 
   // Flag to indicate whether the event loop has been stopped.
-  mutable long stopped_;
+  long stopped_;
 
   // 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,
 
     // 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,
 
     // Completion key value used to wake up a thread to dispatch timers or
     // completed operations.
     wake_for_dispatch = 1,
 
     // 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
   };
 
   // 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_;
+  boost::scoped_ptr<thread> timer_thread_;
 
   // A waitable timer object used for waiting for timeouts.
   auto_handle waitable_timer_;
 
   // Non-zero if timers or completed operations need to be dispatched.
   long dispatch_required_;
 
   // Mutex for protecting access to the timer queues and completed operations.
   mutex dispatch_mutex_;
 
   // The timer queues.
   timer_queue_set timer_queues_;
 
   // The operations that are ready to dispatch.
   op_queue<win_iocp_operation> completed_ops_;
 };
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #include <boost/asio/detail/impl/win_iocp_io_service.hpp>
 #if defined(BOOST_ASIO_HEADER_ONLY)
 # include <boost/asio/detail/impl/win_iocp_io_service.ipp>
 #endif // defined(BOOST_ASIO_HEADER_ONLY)
 
 #endif // defined(BOOST_ASIO_HAS_IOCP)
 
 #endif // BOOST_ASIO_DETAIL_WIN_IOCP_IO_SERVICE_HPP
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
index ec31fa1..b6da9ec 100644
--- 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
@@ -1,35 +1,35 @@
 //
 // detail/win_iocp_io_service_fwd.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_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..b3ecbbd 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,121 +1,114 @@
 //
 // detail/win_iocp_null_buffers_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_WIN_IOCP_NULL_BUFFERS_OP_HPP
 #define BOOST_ASIO_DETAIL_WIN_IOCP_NULL_BUFFERS_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/utility/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>
 #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 {
 
 template <typename Handler>
 class win_iocp_null_buffers_op : public reactor_op
 {
 public:
   BOOST_ASIO_DEFINE_HANDLER_PTR(win_iocp_null_buffers_op);
 
   win_iocp_null_buffers_op(socket_ops::weak_cancel_token_type cancel_token,
-      Handler& handler)
+      Handler handler)
     : reactor_op(&win_iocp_null_buffers_op::do_perform,
         &win_iocp_null_buffers_op::do_complete),
       cancel_token_(cancel_token),
-      handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler))
+      handler_(handler)
   {
   }
 
   static bool do_perform(reactor_op*)
   {
     return true;
   }
 
   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, 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 };
 
-    BOOST_ASIO_HANDLER_COMPLETION((o));
-
     // The reactor may have stored a result in the operation object.
     if (o->ec_)
       ec = o->ec_;
 
     // Map non-portable errors to their portable counterparts.
     if (ec.value() == ERROR_NETNAME_DELETED)
     {
       if (o->cancel_token_.expired())
         ec = boost::asio::error::operation_aborted;
       else
         ec = boost::asio::error::connection_reset;
     }
     else if (ec.value() == ERROR_PORT_UNREACHABLE)
     {
       ec = boost::asio::error::connection_refused;
     }
 
     // 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.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::detail::fenced_block b;
       boost_asio_handler_invoke_helpers::invoke(handler, handler.handler_);
-      BOOST_ASIO_HANDLER_INVOCATION_END;
     }
   }
 
 private:
   socket_ops::weak_cancel_token_type cancel_token_;
   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_NULL_BUFFERS_OP_HPP
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..3963479 100644
--- a/3rdParty/Boost/src/boost/asio/detail/win_iocp_operation.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/win_iocp_operation.hpp
@@ -1,91 +1,87 @@
 //
 // detail/win_iocp_operation.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_WIN_IOCP_OPERATION_HPP
 #define BOOST_ASIO_DETAIL_WIN_IOCP_OPERATION_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/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 {
 
 // 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
 {
 public:
   void complete(win_iocp_io_service& owner,
-      const boost::system::error_code& ec,
-      std::size_t bytes_transferred)
+      const boost::system::error_code& ec = boost::system::error_code(),
+      std::size_t bytes_transferred = 0)
   {
     func_(&owner, this, ec, bytes_transferred);
   }
 
   void destroy()
   {
     func_(0, this, boost::system::error_code(), 0);
   }
 
 protected:
-  typedef void (*func_type)(
-      win_iocp_io_service*, win_iocp_operation*,
-      const boost::system::error_code&, std::size_t);
+  typedef void (*func_type)(win_iocp_io_service*,
+      win_iocp_operation*, boost::system::error_code, std::size_t);
 
   win_iocp_operation(func_type func)
     : next_(0),
       func_(func)
   {
     reset();
   }
 
   // Prevents deletion through this type.
   ~win_iocp_operation()
   {
   }
 
   void reset()
   {
     Internal = 0;
     InternalHigh = 0;
     Offset = 0;
     OffsetHigh = 0;
     hEvent = 0;
     ready_ = 0;
   }
 
 private:
   friend class op_queue_access;
   friend class win_iocp_io_service;
   win_iocp_operation* next_;
   func_type func_;
   long ready_;
 };
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
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..149eaa5 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,90 +1,86 @@
 //
 // detail/win_iocp_overlapped_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_WIN_IOCP_OVERLAPPED_OP_HPP
 #define BOOST_ASIO_DETAIL_WIN_IOCP_OVERLAPPED_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/error.hpp>
 #include <boost/utility/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/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 template <typename Handler>
 class win_iocp_overlapped_op : public operation
 {
 public:
   BOOST_ASIO_DEFINE_HANDLER_PTR(win_iocp_overlapped_op);
 
-  win_iocp_overlapped_op(Handler& handler)
+  win_iocp_overlapped_op(Handler handler)
     : operation(&win_iocp_overlapped_op::do_complete),
-      handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler))
+      handler_(handler)
   {
   }
 
   static void do_complete(io_service_impl* owner, operation* base,
-      const boost::system::error_code& ec, std::size_t bytes_transferred)
+      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 };
 
-    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.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::detail::fenced_block b;
       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_OVERLAPPED_OP_HPP
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..c560bc3 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,123 +1,119 @@
 //
 // detail/win_iocp_overlapped_ptr.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_WIN_IOCP_OVERLAPPED_PTR_HPP
 #define BOOST_ASIO_DETAIL_WIN_IOCP_OVERLAPPED_PTR_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/utility/addressof.hpp>
 #include <boost/asio/io_service.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>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 // Wraps a handler to create an OVERLAPPED object for use with overlapped I/O.
 class win_iocp_overlapped_ptr
   : private noncopyable
 {
 public:
   // Construct an empty win_iocp_overlapped_ptr.
   win_iocp_overlapped_ptr()
     : ptr_(0),
       iocp_service_(0)
   {
   }
 
   // Construct an win_iocp_overlapped_ptr to contain the specified handler.
   template <typename Handler>
   explicit win_iocp_overlapped_ptr(
-      boost::asio::io_service& io_service, BOOST_ASIO_MOVE_ARG(Handler) handler)
+      boost::asio::io_service& io_service, Handler handler)
     : ptr_(0),
       iocp_service_(0)
   {
-    this->reset(io_service, BOOST_ASIO_MOVE_CAST(Handler)(handler));
+    this->reset(io_service, handler);
   }
 
   // Destructor automatically frees the OVERLAPPED object unless released.
   ~win_iocp_overlapped_ptr()
   {
     reset();
   }
 
   // Reset to empty.
   void reset()
   {
     if (ptr_)
     {
       ptr_->destroy();
       ptr_ = 0;
       iocp_service_->work_finished();
       iocp_service_ = 0;
     }
   }
 
   // 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),
       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"));
-
     io_service.impl_.work_started();
     reset();
     ptr_ = p.p;
     p.v = p.p = 0;
     iocp_service_ = &io_service.impl_;
   }
 
   // Get the contained OVERLAPPED object.
   OVERLAPPED* get()
   {
     return ptr_;
   }
 
   // Get the contained OVERLAPPED object.
   const OVERLAPPED* get() const
   {
     return ptr_;
   }
 
   // Release ownership of the OVERLAPPED object.
   OVERLAPPED* release()
   {
     if (ptr_)
       iocp_service_->on_pending(ptr_);
 
     OVERLAPPED* tmp = ptr_;
     ptr_ = 0;
     iocp_service_ = 0;
     return tmp;
   }
 
   // Post completion notification for overlapped operation. Releases ownership.
   void complete(const boost::system::error_code& ec,
       std::size_t bytes_transferred)
   {
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..8b543d2 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,141 +1,125 @@
 //
 // detail/win_iocp_serial_port_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2011 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)
 //
 
 #ifndef BOOST_ASIO_DETAIL_WIN_IOCP_SERIAL_PORT_SERVICE_HPP
 #define BOOST_ASIO_DETAIL_WIN_IOCP_SERIAL_PORT_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_HAS_IOCP) && defined(BOOST_ASIO_HAS_SERIAL_PORT)
 
 #include <string>
 #include <boost/asio/error.hpp>
 #include <boost/asio/io_service.hpp>
 #include <boost/asio/detail/win_iocp_handle_service.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 // Extend win_iocp_handle_service to provide serial port support.
 class win_iocp_serial_port_service
 {
 public:
   // The native type of a serial port.
-  typedef win_iocp_handle_service::native_handle_type native_handle_type;
+  typedef win_iocp_handle_service::native_type native_type;
 
   // The implementation type of the serial port.
   typedef win_iocp_handle_service::implementation_type implementation_type;
 
   // Constructor.
   BOOST_ASIO_DECL win_iocp_serial_port_service(
       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 serial port implementation.
   void construct(implementation_type& impl)
   {
     handle_service_.construct(impl);
   }
 
-  // Move-construct a new serial port implementation.
-  void move_construct(implementation_type& impl,
-      implementation_type& other_impl)
-  {
-    handle_service_.move_construct(impl, other_impl);
-  }
-
-  // Move-assign from another serial port implementation.
-  void move_assign(implementation_type& impl,
-      win_iocp_serial_port_service& other_service,
-      implementation_type& other_impl)
-  {
-    handle_service_.move_assign(impl,
-        other_service.handle_service_, other_impl);
-  }
-
   // Destroy a serial port implementation.
   void destroy(implementation_type& impl)
   {
     handle_service_.destroy(impl);
   }
 
   // Open the serial port using the specified device name.
   BOOST_ASIO_DECL boost::system::error_code open(implementation_type& impl,
       const std::string& device, boost::system::error_code& ec);
 
   // Assign a native handle to a serial port implementation.
   boost::system::error_code assign(implementation_type& impl,
-      const native_handle_type& handle, boost::system::error_code& ec)
+      const native_type& native_handle, boost::system::error_code& ec)
   {
-    return handle_service_.assign(impl, handle, ec);
+    return handle_service_.assign(impl, native_handle, ec);
   }
 
   // Determine whether the serial port is open.
   bool is_open(const implementation_type& impl) const
   {
     return handle_service_.is_open(impl);
   }
 
   // Destroy a serial port implementation.
   boost::system::error_code close(implementation_type& impl,
       boost::system::error_code& ec)
   {
     return handle_service_.close(impl, ec);
   }
 
   // Get the native serial port representation.
-  native_handle_type native_handle(implementation_type& impl)
+  native_type native(implementation_type& impl)
   {
-    return handle_service_.native_handle(impl);
+    return handle_service_.native(impl);
   }
 
   // Cancel all operations associated with the handle.
   boost::system::error_code cancel(implementation_type& impl,
       boost::system::error_code& ec)
   {
     return handle_service_.cancel(impl, ec);
   }
 
   // Set an option on the serial port.
   template <typename SettableSerialPortOption>
   boost::system::error_code set_option(implementation_type& impl,
       const SettableSerialPortOption& option, boost::system::error_code& ec)
   {
     return do_set_option(impl,
         &win_iocp_serial_port_service::store_option<SettableSerialPortOption>,
         &option, ec);
   }
 
   // Get an option from the serial port.
   template <typename GettableSerialPortOption>
   boost::system::error_code get_option(const implementation_type& impl,
       GettableSerialPortOption& option, boost::system::error_code& ec) const
   {
     return do_get_option(impl,
         &win_iocp_serial_port_service::load_option<GettableSerialPortOption>,
         &option, ec);
   }
 
   // Send a break sequence to the serial port.
   boost::system::error_code send_break(implementation_type&,
       boost::system::error_code& ec)
   {
     ec = boost::asio::error::operation_not_supported;
     return ec;
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..ecc1f2d 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,167 +1,160 @@
 //
 // detail/win_iocp_socket_accept_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_WIN_IOCP_SOCKET_ACCEPT_OP_HPP
 #define BOOST_ASIO_DETAIL_WIN_IOCP_SOCKET_ACCEPT_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/utility/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>
 #include <boost/asio/detail/socket_ops.hpp>
 #include <boost/asio/detail/win_iocp_socket_service_base.hpp>
 #include <boost/asio/error.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 template <typename Socket, typename Protocol, typename Handler>
 class win_iocp_socket_accept_op : public operation
 {
 public:
   BOOST_ASIO_DEFINE_HANDLER_PTR(win_iocp_socket_accept_op);
 
   win_iocp_socket_accept_op(win_iocp_socket_service_base& socket_service,
       socket_type socket, Socket& peer, const Protocol& protocol,
       typename Protocol::endpoint* peer_endpoint,
-      bool enable_connection_aborted, Handler& handler)
+      bool enable_connection_aborted, Handler handler)
     : operation(&win_iocp_socket_accept_op::do_complete),
       socket_service_(socket_service),
       socket_(socket),
       peer_(peer),
       protocol_(protocol),
       peer_endpoint_(peer_endpoint),
       enable_connection_aborted_(enable_connection_aborted),
-      handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler))
+      handler_(handler)
   {
   }
 
   socket_holder& new_socket()
   {
     return new_socket_;
   }
 
   void* output_buffer()
   {
     return output_buffer_;
   }
 
   DWORD address_length()
   {
     return sizeof(sockaddr_storage_type) + 16;
   }
 
   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, 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 };
 
     if (owner)
     {
       typename Protocol::endpoint peer_endpoint;
       std::size_t addr_len = peer_endpoint.capacity();
       socket_ops::complete_iocp_accept(o->socket_,
           o->output_buffer(), o->address_length(),
           peer_endpoint.data(), &addr_len,
           o->new_socket_.get(), ec);
 
       // Restart the accept operation if we got the connection_aborted error
       // and the enable_connection_aborted socket option is not set.
       if (ec == boost::asio::error::connection_aborted
           && !o->enable_connection_aborted_)
       {
         o->reset();
         o->socket_service_.restart_accept_op(o->socket_,
             o->new_socket_, o->protocol_.family(),
             o->protocol_.type(), o->protocol_.protocol(),
             o->output_buffer(), o->address_length(), o);
         p.v = p.p = 0;
         return;
       }
 
       // If the socket was successfully accepted, transfer ownership of the
       // socket to the peer object.
       if (!ec)
       {
         o->peer_.assign(o->protocol_,
-            typename Socket::native_handle_type(
+            typename Socket::native_type(
               o->new_socket_.get(), peer_endpoint), ec);
         if (!ec)
           o->new_socket_.release();
       }
 
       // Pass endpoint back to caller.
       if (o->peer_endpoint_)
         *o->peer_endpoint_ = peer_endpoint;
     }
 
-    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::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::detail::fenced_block b;
       boost_asio_handler_invoke_helpers::invoke(handler, handler.handler_);
-      BOOST_ASIO_HANDLER_INVOCATION_END;
     }
   }
 
 private:
   win_iocp_socket_service_base& socket_service_;
   socket_type socket_;
   socket_holder new_socket_;
   Socket& peer_;
   Protocol protocol_;
   typename Protocol::endpoint* peer_endpoint_;
   unsigned char output_buffer_[(sizeof(sockaddr_storage_type) + 16) * 2];
   bool enable_connection_aborted_;
   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_ACCEPT_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..61d053c 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,117 +1,110 @@
 //
 // detail/win_iocp_socket_recv_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_WIN_IOCP_SOCKET_RECV_OP_HPP
 #define BOOST_ASIO_DETAIL_WIN_IOCP_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_HAS_IOCP)
 
 #include <boost/utility/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>
 #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 {
 
 template <typename MutableBufferSequence, typename Handler>
 class win_iocp_socket_recv_op : public operation
 {
 public:
   BOOST_ASIO_DEFINE_HANDLER_PTR(win_iocp_socket_recv_op);
 
   win_iocp_socket_recv_op(socket_ops::state_type state,
       socket_ops::weak_cancel_token_type cancel_token,
-      const MutableBufferSequence& buffers, Handler& handler)
+      const MutableBufferSequence& buffers, Handler handler)
     : operation(&win_iocp_socket_recv_op::do_complete),
       state_(state),
       cancel_token_(cancel_token),
       buffers_(buffers),
-      handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler))
+      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, 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 };
 
-    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)
 
     socket_ops::complete_iocp_recv(o->state_, o->cancel_token_,
         buffer_sequence_adapter<boost::asio::mutable_buffer,
           MutableBufferSequence>::all_empty(o->buffers_),
         ec, bytes_transferred);
 
     // 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.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::detail::fenced_block b;
       boost_asio_handler_invoke_helpers::invoke(handler, handler.handler_);
-      BOOST_ASIO_HANDLER_INVOCATION_END;
     }
   }
 
 private:
   socket_ops::state_type state_;
   socket_ops::weak_cancel_token_type cancel_token_;
   MutableBufferSequence buffers_;
   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_RECV_OP_HPP
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..6b364ee 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,125 +1,118 @@
 //
 // detail/win_iocp_socket_recvfrom_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_WIN_IOCP_SOCKET_RECVFROM_OP_HPP
 #define BOOST_ASIO_DETAIL_WIN_IOCP_SOCKET_RECVFROM_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/utility/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>
 #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 {
 
 template <typename MutableBufferSequence, typename Endpoint, typename Handler>
 class win_iocp_socket_recvfrom_op : public operation
 {
 public:
   BOOST_ASIO_DEFINE_HANDLER_PTR(win_iocp_socket_recvfrom_op);
 
   win_iocp_socket_recvfrom_op(Endpoint& endpoint,
       socket_ops::weak_cancel_token_type cancel_token,
-      const MutableBufferSequence& buffers, Handler& handler)
+      const MutableBufferSequence& buffers, Handler handler)
     : operation(&win_iocp_socket_recvfrom_op::do_complete),
       endpoint_(endpoint),
       endpoint_size_(static_cast<int>(endpoint.capacity())),
       cancel_token_(cancel_token),
       buffers_(buffers),
-      handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler))
+      handler_(handler)
   {
   }
 
   int& endpoint_size()
   {
     return endpoint_size_;
   }
 
   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, std::size_t bytes_transferred)
   {
-    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 };
 
-    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)
 
     socket_ops::complete_iocp_recvfrom(o->cancel_token_, ec);
 
     // Record the size of the endpoint returned by the operation.
     o->endpoint_.resize(o->endpoint_size_);
 
     // 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.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::detail::fenced_block b;
       boost_asio_handler_invoke_helpers::invoke(handler, handler.handler_);
-      BOOST_ASIO_HANDLER_INVOCATION_END;
     }
   }
 
 private:
   Endpoint& endpoint_;
   int endpoint_size_;
   socket_ops::weak_cancel_token_type cancel_token_;
   MutableBufferSequence buffers_;
   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_RECVFROM_OP_HPP
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
deleted file mode 100644
index db13fb8..0000000
--- a/3rdParty/Boost/src/boost/asio/detail/win_iocp_socket_recvmsg_op.hpp
+++ /dev/null
@@ -1,118 +0,0 @@
-//
-// detail/win_iocp_socket_recvmsg_op.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_SOCKET_RECVMSG_OP_HPP
-#define BOOST_ASIO_DETAIL_WIN_IOCP_SOCKET_RECVMSG_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/utility/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>
-#include <boost/asio/detail/socket_ops.hpp>
-#include <boost/asio/error.hpp>
-#include <boost/asio/socket_base.hpp>
-
-#include <boost/asio/detail/push_options.hpp>
-
-namespace boost {
-namespace asio {
-namespace detail {
-
-template <typename MutableBufferSequence, typename Handler>
-class win_iocp_socket_recvmsg_op : public operation
-{
-public:
-  BOOST_ASIO_DEFINE_HANDLER_PTR(win_iocp_socket_recvmsg_op);
-
-  win_iocp_socket_recvmsg_op(
-      socket_ops::weak_cancel_token_type cancel_token,
-      const MutableBufferSequence& buffers,
-      socket_base::message_flags& out_flags, Handler& handler)
-    : operation(&win_iocp_socket_recvmsg_op::do_complete),
-      cancel_token_(cancel_token),
-      buffers_(buffers),
-      out_flags_(out_flags),
-      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_recvmsg_op* o(
-        static_cast<win_iocp_socket_recvmsg_op*>(base));
-    ptr p = { boost::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)
-
-    socket_ops::complete_iocp_recvmsg(o->cancel_token_, ec);
-    o->out_flags_ = 0;
-
-    // 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.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:
-  socket_ops::weak_cancel_token_type cancel_token_;
-  MutableBufferSequence buffers_;
-  socket_base::message_flags& out_flags_;
-  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_RECVMSG_OP_HPP
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..33bd380 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,111 +1,104 @@
 //
 // detail/win_iocp_socket_send_op.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_WIN_IOCP_SOCKET_SEND_OP_HPP
 #define BOOST_ASIO_DETAIL_WIN_IOCP_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_HAS_IOCP)
 
 #include <boost/utility/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>
 #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 {
 
 template <typename ConstBufferSequence, typename Handler>
 class win_iocp_socket_send_op : public operation
 {
 public:
   BOOST_ASIO_DEFINE_HANDLER_PTR(win_iocp_socket_send_op);
 
   win_iocp_socket_send_op(socket_ops::weak_cancel_token_type cancel_token,
-      const ConstBufferSequence& buffers, Handler& handler)
+      const ConstBufferSequence& buffers, Handler handler)
     : operation(&win_iocp_socket_send_op::do_complete),
       cancel_token_(cancel_token),
       buffers_(buffers),
-      handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler))
+      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, 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 };
 
-    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)
 
     socket_ops::complete_iocp_send(o->cancel_token_, ec);
 
     // 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.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::detail::fenced_block b;
       boost_asio_handler_invoke_helpers::invoke(handler, handler.handler_);
-      BOOST_ASIO_HANDLER_INVOCATION_END;
     }
   }
 
 private:
   socket_ops::weak_cancel_token_type cancel_token_;
   ConstBufferSequence buffers_;
   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_SEND_OP_HPP
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..183b74b 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,237 +1,204 @@
 //
 // detail/win_iocp_socket_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_WIN_IOCP_SOCKET_SERVICE_HPP
 #define BOOST_ASIO_DETAIL_WIN_IOCP_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_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/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_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>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 template <typename Protocol>
 class win_iocp_socket_service : public win_iocp_socket_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.
-  class native_handle_type
+  class native_type
   {
   public:
-    native_handle_type(socket_type s)
+    native_type(socket_type s)
       : socket_(s),
         have_remote_endpoint_(false)
     {
     }
 
-    native_handle_type(socket_type s, const endpoint_type& ep)
+    native_type(socket_type s, const endpoint_type& ep)
       : socket_(s),
         have_remote_endpoint_(true),
         remote_endpoint_(ep)
     {
     }
 
     void operator=(socket_type s)
     {
       socket_ = s;
       have_remote_endpoint_ = false;
       remote_endpoint_ = endpoint_type();
     }
 
     operator socket_type() const
     {
       return socket_;
     }
 
     bool have_remote_endpoint() const
     {
       return have_remote_endpoint_;
     }
 
     endpoint_type remote_endpoint() const
     {
       return remote_endpoint_;
     }
 
   private:
     socket_type socket_;
     bool have_remote_endpoint_;
     endpoint_type remote_endpoint_;
   };
 
   // The implementation type of the socket.
   struct implementation_type :
     win_iocp_socket_service_base::base_implementation_type
   {
     // Default constructor.
     implementation_type()
       : protocol_(endpoint_type().protocol()),
         have_remote_endpoint_(false),
         remote_endpoint_()
     {
     }
 
     // The protocol associated with the socket.
     protocol_type protocol_;
 
     // Whether we have a cached remote endpoint.
     bool have_remote_endpoint_;
 
     // A cached remote endpoint.
     endpoint_type remote_endpoint_;
   };
 
   // Constructor.
   win_iocp_socket_service(boost::asio::io_service& io_service)
     : win_iocp_socket_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();
-
-    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_ = endpoint_type();
-  }
-
-  // Move-assign from another socket implementation.
-  void move_assign(implementation_type& impl,
-      win_iocp_socket_service_base& 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();
-
-    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_ = endpoint_type();
-  }
-
   // 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))
     {
       impl.protocol_ = protocol;
       impl.have_remote_endpoint_ = false;
       impl.remote_endpoint_ = endpoint_type();
     }
     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,
+      const protocol_type& protocol, const native_type& native_socket,
       boost::system::error_code& ec)
   {
     if (!do_assign(impl, protocol.type(), native_socket, ec))
     {
       impl.protocol_ = protocol;
       impl.have_remote_endpoint_ = native_socket.have_remote_endpoint();
       impl.remote_endpoint_ = native_socket.remote_endpoint();
     }
     return ec;
   }
 
   // Get the native socket representation.
-  native_handle_type native_handle(implementation_type& impl)
+  native_type native(implementation_type& impl)
   {
     if (impl.have_remote_endpoint_)
-      return native_handle_type(impl.socket_, impl.remote_endpoint_);
-    return native_handle_type(impl.socket_);
+      return native_type(impl.socket_, impl.remote_endpoint_);
+    return native_type(impl.socket_);
   }
 
   // Bind the socket to the specified local endpoint.
   boost::system::error_code bind(implementation_type& impl,
       const endpoint_type& endpoint, boost::system::error_code& ec)
   {
     socket_ops::bind(impl.socket_, endpoint.data(), endpoint.size(), ec);
     return ec;
   }
 
   // Set a socket option.
   template <typename Option>
   boost::system::error_code set_option(implementation_type& impl,
       const Option& option, boost::system::error_code& ec)
   {
     socket_ops::setsockopt(impl.socket_, impl.state_,
         option.level(impl.protocol_), option.name(impl.protocol_),
         option.data(impl.protocol_), option.size(impl.protocol_), ec);
     return ec;
   }
 
   // Set 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_);
     socket_ops::getsockopt(impl.socket_, impl.state_,
         option.level(impl.protocol_), option.name(impl.protocol_),
         option.data(impl.protocol_), &size, ec);
     if (!ec)
       option.resize(impl.protocol_, size);
     return ec;
   }
 
@@ -249,261 +216,247 @@ public:
 
   // Get the remote endpoint.
   endpoint_type remote_endpoint(const implementation_type& impl,
       boost::system::error_code& ec) const
   {
     endpoint_type endpoint = impl.remote_endpoint_;
     std::size_t addr_len = endpoint.capacity();
     if (socket_ops::getpeername(impl.socket_, endpoint.data(),
           &addr_len, impl.have_remote_endpoint_, ec))
       return endpoint_type();
     endpoint.resize(addr_len);
     return endpoint;
   }
 
   // Send a datagram to the specified endpoint. Returns the number of bytes
   // sent.
   template <typename ConstBufferSequence>
   size_t send_to(implementation_type& impl, const ConstBufferSequence& buffers,
       const endpoint_type& destination, socket_base::message_flags flags,
       boost::system::error_code& ec)
   {
     buffer_sequence_adapter<boost::asio::const_buffer,
         ConstBufferSequence> bufs(buffers);
 
     return socket_ops::sync_sendto(impl.socket_, impl.state_,
         bufs.buffers(), bufs.count(), flags,
         destination.data(), destination.size(), ec);
   }
 
   // Wait until data can be sent without blocking.
   size_t send_to(implementation_type& impl, const null_buffers&,
       const endpoint_type&, socket_base::message_flags,
       boost::system::error_code& ec)
   {
     // Wait for socket to become ready.
-    socket_ops::poll_write(impl.socket_, impl.state_, ec);
+    socket_ops::poll_write(impl.socket_, ec);
 
     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& impl,
       const ConstBufferSequence& buffers, const endpoint_type& destination,
       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),
       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"));
-
     buffer_sequence_adapter<boost::asio::const_buffer,
         ConstBufferSequence> bufs(buffers);
 
     start_send_to_op(impl, bufs.buffers(), bufs.count(),
         destination.data(), static_cast<int>(destination.size()),
         flags, p.p);
     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)
   {
     // Allocate and construct an operation to wrap the handler.
     typedef win_iocp_null_buffers_op<Handler> op;
     typename op::ptr p = { boost::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)"));
-
     start_reactor_op(impl, reactor::write_op, p.p);
     p.v = p.p = 0;
   }
 
   // Receive a datagram with the endpoint of the sender. Returns the number of
   // bytes received.
   template <typename MutableBufferSequence>
   size_t receive_from(implementation_type& impl,
       const MutableBufferSequence& buffers,
       endpoint_type& sender_endpoint, socket_base::message_flags flags,
       boost::system::error_code& ec)
   {
     buffer_sequence_adapter<boost::asio::mutable_buffer,
         MutableBufferSequence> bufs(buffers);
 
     std::size_t addr_len = sender_endpoint.capacity();
     std::size_t bytes_recvd = socket_ops::sync_recvfrom(
         impl.socket_, impl.state_, bufs.buffers(), bufs.count(),
         flags, sender_endpoint.data(), &addr_len, ec);
 
     if (!ec)
       sender_endpoint.resize(addr_len);
 
     return bytes_recvd;
   }
 
   // Wait until data can be received without blocking.
   size_t receive_from(implementation_type& impl,
       const null_buffers&, endpoint_type& sender_endpoint,
       socket_base::message_flags, boost::system::error_code& ec)
   {
     // Wait for socket to become ready.
-    socket_ops::poll_read(impl.socket_, impl.state_, ec);
+    socket_ops::poll_read(impl.socket_, ec);
 
     // Reset endpoint since it can be given no sensible value at this time.
     sender_endpoint = endpoint_type();
 
     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& impl,
       const MutableBufferSequence& buffers, endpoint_type& sender_endp,
       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),
       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"));
-
     buffer_sequence_adapter<boost::asio::mutable_buffer,
         MutableBufferSequence> bufs(buffers);
 
     start_receive_from_op(impl, bufs.buffers(), bufs.count(),
         sender_endp.data(), flags, &p.p->endpoint_size(), p.p);
     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)
   {
     // Allocate and construct an operation to wrap the handler.
     typedef win_iocp_null_buffers_op<Handler> op;
     typename op::ptr p = { boost::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)"));
-
     // Reset endpoint since it can be given no sensible value at this time.
     sender_endpoint = endpoint_type();
 
     start_null_buffers_receive_op(impl, flags, p.p);
     p.v = p.p = 0;
   }
 
   // Accept a new connection.
   template <typename Socket>
   boost::system::error_code accept(implementation_type& impl, Socket& peer,
       endpoint_type* peer_endpoint, boost::system::error_code& ec)
   {
     // We cannot accept a socket that is already open.
     if (peer.is_open())
     {
       ec = boost::asio::error::already_open;
       return ec;
     }
 
     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 (peer_endpoint)
         peer_endpoint->resize(addr_len);
       if (!peer.assign(impl.protocol_, new_socket.get(), ec))
         new_socket.release();
     }
 
     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& impl, Socket& peer,
       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),
       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);
 
-    BOOST_ASIO_HANDLER_CREATION((p.p, "socket", &impl, "async_accept"));
-
     start_accept_op(impl, peer.is_open(), p.p->new_socket(),
         impl.protocol_.family(), impl.protocol_.type(),
         impl.protocol_.protocol(), p.p->output_buffer(),
         p.p->address_length(), p.p);
     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)
   {
     socket_ops::sync_connect(impl.socket_,
         peer_endpoint.data(), peer_endpoint.size(), ec);
     return ec;
   }
 
   // Start an asynchronous connect.
   template <typename Handler>
   void async_connect(implementation_type& impl,
       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),
       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()));
     p.v = p.p = 0;
   }
 };
 
 } // 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_SERVICE_HPP
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..32532f9 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,436 +1,311 @@
 //
 // detail/win_iocp_socket_service_base.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_WIN_IOCP_SOCKET_SERVICE_BASE_HPP
 #define BOOST_ASIO_DETAIL_WIN_IOCP_SOCKET_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_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/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/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_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>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 class win_iocp_socket_service_base
 {
 public:
   // The implementation type of the socket.
   struct base_implementation_type
   {
     // The native socket representation.
     socket_type socket_;
 
     // The current state of the socket.
     socket_ops::state_type state_;
 
     // We use a shared pointer as a cancellation token here to work around the
     // broken Windows support for cancellation. MSDN says that when you call
     // closesocket any outstanding WSARecv or WSASend operations will complete
     // with the error ERROR_OPERATION_ABORTED. In practice they complete with
     // ERROR_NETNAME_DELETED, which means you can't tell the difference between
     // a local cancellation and the socket being hard-closed by the peer.
     socket_ops::shared_cancel_token_type cancel_token_;
 
     // Per-descriptor data used by the reactor.
     reactor::per_descriptor_data reactor_data_;
 
 #if defined(BOOST_ASIO_ENABLE_CANCELIO)
     // The ID of the thread from which it is safe to cancel asynchronous
     // operations. 0 means no asynchronous operations have been started yet.
     // ~0 means asynchronous operations have been started from more than one
     // thread, and cancellation is not supported for the socket.
     DWORD safe_cancellation_thread_id_;
 #endif // defined(BOOST_ASIO_ENABLE_CANCELIO)
 
     // Pointers to adjacent socket implementations in linked list.
     base_implementation_type* next_;
     base_implementation_type* prev_;
   };
 
   // Constructor.
   BOOST_ASIO_DECL win_iocp_socket_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& impl);
 
-  // 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,
-      win_iocp_socket_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_ != invalid_socket;
   }
 
   // Destroy a socket implementation.
   BOOST_ASIO_DECL boost::system::error_code close(
       base_implementation_type& impl, boost::system::error_code& ec);
 
   // Cancel all operations associated with the socket.
   BOOST_ASIO_DECL boost::system::error_code cancel(
       base_implementation_type& impl, boost::system::error_code& ec);
 
   // Determine whether the socket is at the out-of-band data mark.
   bool at_mark(const base_implementation_type& impl,
       boost::system::error_code& ec) const
   {
     return socket_ops::sockatmark(impl.socket_, ec);
   }
 
   // Determine the number of bytes available for reading.
   std::size_t available(const base_implementation_type& impl,
       boost::system::error_code& ec) const
   {
     return socket_ops::available(impl.socket_, ec);
   }
 
   // Place the socket into the state where it will listen for new connections.
   boost::system::error_code listen(base_implementation_type& impl,
       int backlog, boost::system::error_code& ec)
   {
     socket_ops::listen(impl.socket_, backlog, ec);
     return ec;
   }
 
   // Perform an IO control command on the socket.
   template <typename IO_Control_Command>
   boost::system::error_code io_control(base_implementation_type& impl,
       IO_Control_Command& command, boost::system::error_code& ec)
   {
     socket_ops::ioctl(impl.socket_, impl.state_, command.name(),
         static_cast<ioctl_arg_type*>(command.data()), ec);
     return ec;
   }
 
-  // Gets the non-blocking mode of the socket.
-  bool non_blocking(const base_implementation_type& impl) const
-  {
-    return (impl.state_ & socket_ops::user_set_non_blocking) != 0;
-  }
-
-  // Sets the non-blocking mode of the socket.
-  boost::system::error_code non_blocking(base_implementation_type& impl,
-      bool mode, boost::system::error_code& ec)
-  {
-    socket_ops::set_user_non_blocking(impl.socket_, impl.state_, mode, ec);
-    return ec;
-  }
-
-  // Gets the non-blocking mode of the native socket implementation.
-  bool native_non_blocking(const base_implementation_type& impl) const
-  {
-    return (impl.state_ & socket_ops::internal_non_blocking) != 0;
-  }
-
-  // Sets the non-blocking mode of the native socket implementation.
-  boost::system::error_code native_non_blocking(base_implementation_type& impl,
-      bool mode, boost::system::error_code& ec)
-  {
-    socket_ops::set_internal_non_blocking(impl.socket_, impl.state_, mode, ec);
-    return ec;
-  }
-
-  // Disable sends or receives on the socket.
+  /// Disable sends or receives on the socket.
   boost::system::error_code shutdown(base_implementation_type& impl,
       socket_base::shutdown_type what, boost::system::error_code& ec)
   {
     socket_ops::shutdown(impl.socket_, what, ec);
     return ec;
   }
 
   // Send the given data to the peer. Returns the number of bytes sent.
   template <typename ConstBufferSequence>
   size_t send(base_implementation_type& impl,
       const ConstBufferSequence& buffers,
       socket_base::message_flags flags, boost::system::error_code& ec)
   {
     buffer_sequence_adapter<boost::asio::const_buffer,
         ConstBufferSequence> bufs(buffers);
 
     return socket_ops::sync_send(impl.socket_, impl.state_,
         bufs.buffers(), bufs.count(), flags, bufs.all_empty(), ec);
   }
 
   // Wait until data can be sent without blocking.
   size_t send(base_implementation_type& impl, const null_buffers&,
       socket_base::message_flags, boost::system::error_code& ec)
   {
     // Wait for socket to become ready.
-    socket_ops::poll_write(impl.socket_, impl.state_, ec);
+    socket_ops::poll_write(impl.socket_, ec);
 
     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)
   {
     // 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),
       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"));
-
     buffer_sequence_adapter<boost::asio::const_buffer,
         ConstBufferSequence> bufs(buffers);
 
     start_send_op(impl, bufs.buffers(), bufs.count(), flags,
         (impl.state_ & socket_ops::stream_oriented) != 0 && bufs.all_empty(),
         p.p);
     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)
   {
     // Allocate and construct an operation to wrap the handler.
     typedef win_iocp_null_buffers_op<Handler> op;
     typename op::ptr p = { boost::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)"));
-
     start_reactor_op(impl, reactor::write_op, p.p);
     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,
       const MutableBufferSequence& buffers,
       socket_base::message_flags flags, boost::system::error_code& ec)
   {
     buffer_sequence_adapter<boost::asio::mutable_buffer,
         MutableBufferSequence> bufs(buffers);
 
     return socket_ops::sync_recv(impl.socket_, impl.state_,
         bufs.buffers(), bufs.count(), flags, bufs.all_empty(), ec);
   }
 
   // Wait until data can be received without blocking.
   size_t receive(base_implementation_type& impl, const null_buffers&,
       socket_base::message_flags, boost::system::error_code& ec)
   {
     // Wait for socket to become ready.
-    socket_ops::poll_read(impl.socket_, impl.state_, ec);
+    socket_ops::poll_read(impl.socket_, ec);
 
     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)
   {
     // 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),
       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"));
-
     buffer_sequence_adapter<boost::asio::mutable_buffer,
         MutableBufferSequence> bufs(buffers);
 
     start_receive_op(impl, bufs.buffers(), bufs.count(), flags,
         (impl.state_ & socket_ops::stream_oriented) != 0 && bufs.all_empty(),
         p.p);
     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)
   {
     // Allocate and construct an operation to wrap the handler.
     typedef win_iocp_null_buffers_op<Handler> op;
     typename op::ptr p = { boost::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)"));
-
     start_null_buffers_receive_op(impl, flags, p.p);
     p.v = p.p = 0;
   }
 
-  // Receive some data with associated flags. Returns the number of bytes
-  // received.
-  template <typename MutableBufferSequence>
-  size_t receive_with_flags(base_implementation_type& impl,
-      const MutableBufferSequence& buffers,
-      socket_base::message_flags in_flags,
-      socket_base::message_flags& out_flags, boost::system::error_code& ec)
-  {
-    buffer_sequence_adapter<boost::asio::mutable_buffer,
-        MutableBufferSequence> bufs(buffers);
-
-    return socket_ops::sync_recvmsg(impl.socket_, impl.state_,
-        bufs.buffers(), bufs.count(), in_flags, out_flags, ec);
-  }
-
-  // Wait until data can be received without blocking.
-  size_t receive_with_flags(base_implementation_type& impl,
-      const null_buffers&, socket_base::message_flags,
-      socket_base::message_flags& out_flags, boost::system::error_code& ec)
-  {
-    // Wait for socket to become ready.
-    socket_ops::poll_read(impl.socket_, impl.state_, ec);
-
-    // Clear out_flags, since we cannot give it any other sensible value when
-    // performing a null_buffers operation.
-    out_flags = 0;
-
-    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(base_implementation_type& impl,
-      const MutableBufferSequence& buffers, socket_base::message_flags in_flags,
-      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),
-      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"));
-
-    buffer_sequence_adapter<boost::asio::mutable_buffer,
-        MutableBufferSequence> bufs(buffers);
-
-    start_receive_op(impl, bufs.buffers(), bufs.count(), in_flags, false, p.p);
-    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)
-  {
-    // Allocate and construct an operation to wrap the handler.
-    typedef win_iocp_null_buffers_op<Handler> op;
-    typename op::ptr p = { boost::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)"));
-
-    // Reset out_flags since it can be given no sensible value at this time.
-    out_flags = 0;
-
-    start_null_buffers_receive_op(impl, in_flags, p.p);
-    p.v = p.p = 0;
-  }
-
   // Helper function to restart an asynchronous accept operation.
   BOOST_ASIO_DECL void restart_accept_op(socket_type s,
       socket_holder& new_socket, int family, int type, int protocol,
       void* output_buffer, DWORD address_length, operation* op);
 
 protected:
   // Open a new socket implementation.
   BOOST_ASIO_DECL boost::system::error_code do_open(
       base_implementation_type& impl, int family, int type,
       int protocol, boost::system::error_code& ec);
 
   // Assign a native socket to a socket implementation.
   BOOST_ASIO_DECL boost::system::error_code do_assign(
       base_implementation_type& impl, int type,
       socket_type native_socket, boost::system::error_code& ec);
 
   // Helper function to start an asynchronous send operation.
   BOOST_ASIO_DECL void start_send_op(base_implementation_type& impl,
       WSABUF* buffers, std::size_t buffer_count,
       socket_base::message_flags flags, bool noop, operation* op);
 
   // Helper function to start an asynchronous send_to operation.
   BOOST_ASIO_DECL void start_send_to_op(base_implementation_type& impl,
       WSABUF* buffers, std::size_t buffer_count,
       const socket_addr_type* addr, int addrlen,
       socket_base::message_flags flags, operation* op);
 
   // Helper function to start an asynchronous receive operation.
   BOOST_ASIO_DECL void start_receive_op(base_implementation_type& impl,
       WSABUF* buffers, std::size_t buffer_count,
       socket_base::message_flags flags, bool noop, operation* op);
 
   // Helper function to start an asynchronous null_buffers receive operation.
   BOOST_ASIO_DECL void start_null_buffers_receive_op(
       base_implementation_type& impl,
diff --git a/3rdParty/Boost/src/boost/asio/detail/win_mutex.hpp b/3rdParty/Boost/src/boost/asio/detail/win_mutex.hpp
index 930d01f..0c5dc26 100644
--- a/3rdParty/Boost/src/boost/asio/detail/win_mutex.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/win_mutex.hpp
@@ -1,40 +1,40 @@
 //
 // detail/win_mutex.hpp
 // ~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_WIN_MUTEX_HPP
 #define BOOST_ASIO_DETAIL_WIN_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_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>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 class win_mutex
   : private noncopyable
 {
 public:
   typedef boost::asio::detail::scoped_lock<win_mutex> scoped_lock;
 
   // Constructor.
   BOOST_ASIO_DECL win_mutex();
 
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
deleted file mode 100644
index 52a972d..0000000
--- a/3rdParty/Boost/src/boost/asio/detail/win_object_handle_service.hpp
+++ /dev/null
@@ -1,185 +0,0 @@
-//
-// detail/win_object_handle_service.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2012 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)
-//
-
-#ifndef BOOST_ASIO_DETAIL_WIN_OBJECT_HANDLE_SERVICE_HPP
-#define BOOST_ASIO_DETAIL_WIN_OBJECT_HANDLE_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_HAS_WINDOWS_OBJECT_HANDLE)
-
-#include <boost/utility/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>
-
-namespace boost {
-namespace asio {
-namespace detail {
-
-class win_object_handle_service
-{
-public:
-  // The native type of an object handle.
-  typedef HANDLE native_handle_type;
-
-  // The implementation type of the object handle.
-  class implementation_type
-  {
-   public:
-    // Default constructor.
-    implementation_type()
-      : handle_(INVALID_HANDLE_VALUE),
-        wait_handle_(INVALID_HANDLE_VALUE),
-        owner_(0),
-        next_(0),
-        prev_(0)
-    {
-    }
-
-  private:
-    // Only this service will have access to the internal values.
-    friend class win_object_handle_service;
-
-    // The native object handle representation. May be accessed or modified
-    // without locking the mutex.
-    native_handle_type handle_;
-
-    // The handle used to unregister the wait operation. The mutex must be
-    // locked when accessing or modifying this member.
-    HANDLE wait_handle_;
-
-    // The operations waiting on the object handle. If there is a registered
-    // wait then the mutex must be locked when accessing or modifying this
-    // member
-    op_queue<wait_op> op_queue_;
-
-    // The service instance that owns the object handle implementation.
-    win_object_handle_service* owner_;
-
-    // Pointers to adjacent handle implementations in linked list. The mutex
-    // must be locked when accessing or modifying these members.
-    implementation_type* next_;
-    implementation_type* prev_;
-  };
-
-  // Constructor.
-  BOOST_ASIO_DECL win_object_handle_service(
-      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 handle implementation.
-  BOOST_ASIO_DECL void construct(implementation_type& impl);
-
-  // Move-construct a new handle implementation.
-  BOOST_ASIO_DECL void move_construct(implementation_type& impl,
-      implementation_type& other_impl);
-
-  // Move-assign from another handle implementation.
-  BOOST_ASIO_DECL void move_assign(implementation_type& impl,
-      win_object_handle_service& other_service,
-      implementation_type& other_impl);
-
-  // Destroy a handle implementation.
-  BOOST_ASIO_DECL void destroy(implementation_type& impl);
-
-  // Assign a native handle to a handle implementation.
-  BOOST_ASIO_DECL boost::system::error_code assign(implementation_type& impl,
-      const native_handle_type& handle, boost::system::error_code& ec);
-
-  // Determine whether the handle is open.
-  bool is_open(const implementation_type& impl) const
-  {
-    return impl.handle_ != INVALID_HANDLE_VALUE && impl.handle_ != 0;
-  }
-
-  // Destroy a handle implementation.
-  BOOST_ASIO_DECL boost::system::error_code close(implementation_type& impl,
-      boost::system::error_code& ec);
-
-  // Get the native handle representation.
-  native_handle_type native_handle(const implementation_type& impl) const
-  {
-    return impl.handle_;
-  }
-
-  // Cancel all operations associated with the handle.
-  BOOST_ASIO_DECL boost::system::error_code cancel(implementation_type& impl,
-      boost::system::error_code& ec);
-
-  // 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)
-  {
-    // Allocate and construct an operation to wrap the handler.
-    typedef wait_handler<Handler> op;
-    typename op::ptr p = { boost::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"));
-
-    start_wait_op(impl, p.p);
-    p.v = p.p = 0;
-  }
-
-private:
-  // Helper function to start an asynchronous wait operation.
-  BOOST_ASIO_DECL void start_wait_op(implementation_type& impl, wait_op* op);
-
-  // Helper function to register a wait operation.
-  BOOST_ASIO_DECL void register_wait_callback(
-      implementation_type& impl, mutex::scoped_lock& lock);
-
-  // Callback function invoked when the registered wait completes.
-  static BOOST_ASIO_DECL VOID CALLBACK wait_callback(
-      PVOID param, BOOLEAN timeout);
-
-  // The io_service implementation used to post completions.
-  io_service_impl& io_service_;
-
-  // Mutex to protect access to internal state.
-  mutex mutex_;
-
-  // The head of a linked list of all implementations.
-  implementation_type* impl_list_;
-
-  // Flag to indicate that the dispatcher has been shut down.
-  bool shutdown_;
-};
-
-} // 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_object_handle_service.ipp>
-#endif // defined(BOOST_ASIO_HEADER_ONLY)
-
-#endif // defined(BOOST_ASIO_HAS_WINDOWS_OBJECT_HANDLE)
-
-#endif // BOOST_ASIO_DETAIL_WIN_OBJECT_HANDLE_SERVICE_HPP
diff --git a/3rdParty/Boost/src/boost/asio/detail/win_static_mutex.hpp b/3rdParty/Boost/src/boost/asio/detail/win_static_mutex.hpp
deleted file mode 100644
index a54b36b..0000000
--- a/3rdParty/Boost/src/boost/asio/detail/win_static_mutex.hpp
+++ /dev/null
@@ -1,76 +0,0 @@
-//
-// detail/win_static_mutex.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_STATIC_MUTEX_HPP
-#define BOOST_ASIO_DETAIL_WIN_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_WINDOWS)
-
-#include <boost/asio/detail/scoped_lock.hpp>
-
-#include <boost/asio/detail/push_options.hpp>
-
-namespace boost {
-namespace asio {
-namespace detail {
-
-struct win_static_mutex
-{
-  typedef boost::asio::detail::scoped_lock<win_static_mutex> scoped_lock;
-
-  // Initialise the mutex.
-  BOOST_ASIO_DECL void init();
-
-  // Initialisation must be performed in a separate function to the "public"
-  // init() function since the compiler does not support the use of structured
-  // exceptions and C++ exceptions in the same function.
-  BOOST_ASIO_DECL int do_init();
-
-  // Lock the mutex.
-  void lock()
-  {
-    ::EnterCriticalSection(&crit_section_);
-  }
-
-  // Unlock the mutex.
-  void unlock()
-  {
-    ::LeaveCriticalSection(&crit_section_);
-  }
-
-  bool initialised_;
-  ::CRITICAL_SECTION crit_section_;
-};
-
-#if defined(UNDER_CE)
-# define BOOST_ASIO_WIN_STATIC_MUTEX_INIT { false, { 0, 0, 0, 0, 0 } }
-#else // defined(UNDER_CE)
-# define BOOST_ASIO_WIN_STATIC_MUTEX_INIT { false, { 0, 0, 0, 0, 0, 0 } }
-#endif // defined(UNDER_CE)
-
-} // 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_static_mutex.ipp>
-#endif // defined(BOOST_ASIO_HEADER_ONLY)
-
-#endif // defined(BOOST_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..4e33bd9 100644
--- a/3rdParty/Boost/src/boost/asio/detail/win_thread.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/win_thread.hpp
@@ -1,40 +1,40 @@
 //
 // detail/win_thread.hpp
 // ~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_WIN_THREAD_HPP
 #define BOOST_ASIO_DETAIL_WIN_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_WINDOWS) && !defined(UNDER_CE)
 
 #include <boost/asio/detail/noncopyable.hpp>
 #include <boost/asio/detail/socket_types.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 BOOST_ASIO_DECL unsigned int __stdcall win_thread_function(void* arg);
 
 #if defined(WINVER) && (WINVER < 0x0500)
 BOOST_ASIO_DECL void __stdcall apc_function(ULONG data);
 #else
 BOOST_ASIO_DECL void __stdcall apc_function(ULONG_PTR data);
 #endif
 
 template <typename T>
 class win_thread_base
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..75811c1 100644
--- a/3rdParty/Boost/src/boost/asio/detail/win_tss_ptr.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/win_tss_ptr.hpp
@@ -1,40 +1,40 @@
 //
 // detail/win_tss_ptr.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_WIN_TSS_PTR_HPP
 #define BOOST_ASIO_DETAIL_WIN_TSS_PTR_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_WINDOWS)
 
 #include <boost/asio/detail/noncopyable.hpp>
 #include <boost/asio/detail/socket_types.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 // Helper function to create thread-specific storage.
 BOOST_ASIO_DECL DWORD win_tss_ptr_create();
 
 template <typename T>
 class win_tss_ptr
   : private noncopyable
 {
 public:
   // Constructor.
   win_tss_ptr()
diff --git a/3rdParty/Boost/src/boost/asio/detail/wince_thread.hpp b/3rdParty/Boost/src/boost/asio/detail/wince_thread.hpp
index 389cb9d..7f7b1e4 100644
--- a/3rdParty/Boost/src/boost/asio/detail/wince_thread.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/wince_thread.hpp
@@ -1,77 +1,77 @@
 //
 // detail/wince_thread.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_WINCE_THREAD_HPP
 #define BOOST_ASIO_DETAIL_WINCE_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_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>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 DWORD WINAPI wince_thread_function(LPVOID arg);
 
 class wince_thread
   : private noncopyable
 {
 public:
   // Constructor.
   template <typename Function>
-  wince_thread(Function f, unsigned int = 0)
+  wince_thread(Function f)
   {
     std::auto_ptr<func_base> arg(new func<Function>(f));
     DWORD thread_id = 0;
     thread_ = ::CreateThread(0, 0, wince_thread_function,
         arg.get(), 0, &thread_id);
     if (!thread_)
     {
       DWORD last_error = ::GetLastError();
       boost::system::error_code ec(last_error,
           boost::asio::error::get_system_category());
       boost::asio::detail::throw_error(ec, "thread");
     }
     arg.release();
   }
 
   // Destructor.
   ~wince_thread()
   {
     ::CloseHandle(thread_);
   }
 
   // Wait for the thread to exit.
   void join()
   {
     ::WaitForSingleObject(thread_, INFINITE);
   }
 
 private:
   friend DWORD WINAPI wince_thread_function(LPVOID arg);
 
   class func_base
   {
   public:
     virtual ~func_base() {}
     virtual void run() = 0;
diff --git a/3rdParty/Boost/src/boost/asio/detail/winsock_init.hpp b/3rdParty/Boost/src/boost/asio/detail/winsock_init.hpp
index 702ba71..dc50fbf 100644
--- a/3rdParty/Boost/src/boost/asio/detail/winsock_init.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/winsock_init.hpp
@@ -1,40 +1,40 @@
 //
 // detail/winsock_init.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_WINSOCK_INIT_HPP
 #define BOOST_ASIO_DETAIL_WINSOCK_INIT_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_WINDOWS) || defined(__CYGWIN__)
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 class winsock_init_base
 {
 protected:
   // Structure to track result of initialisation and number of uses. POD is used
   // to ensure that the values are zero-initialised prior to any code being run.
   struct data
   {
     long init_count_;
     long result_;
   };
 
   BOOST_ASIO_DECL static void startup(data& d,
       unsigned char major, unsigned char minor);
diff --git a/3rdParty/Boost/src/boost/asio/detail/wrapped_handler.hpp b/3rdParty/Boost/src/boost/asio/detail/wrapped_handler.hpp
index d82da22..b326847 100644
--- a/3rdParty/Boost/src/boost/asio/detail/wrapped_handler.hpp
+++ b/3rdParty/Boost/src/boost/asio/detail/wrapped_handler.hpp
@@ -1,87 +1,73 @@
 //
 // detail/wrapped_handler.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_WRAPPED_HANDLER_HPP
 #define BOOST_ASIO_DETAIL_WRAPPED_HANDLER_HPP
 
 #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_invoke_helpers.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace detail {
 
 template <typename Dispatcher, typename Handler>
 class wrapped_handler
 {
 public:
   typedef void result_type;
 
-  wrapped_handler(Dispatcher dispatcher, Handler& handler)
+  wrapped_handler(Dispatcher dispatcher, Handler handler)
     : dispatcher_(dispatcher),
-      handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler))
-  {
-  }
-
-#if defined(BOOST_ASIO_HAS_MOVE)
-  wrapped_handler(const wrapped_handler& other)
-    : dispatcher_(other.dispatcher_),
-      handler_(other.handler_)
-  {
-  }
-
-  wrapped_handler(wrapped_handler&& other)
-    : dispatcher_(other.dispatcher_),
-      handler_(BOOST_ASIO_MOVE_CAST(Handler)(other.handler_))
+      handler_(handler)
   {
   }
-#endif // defined(BOOST_ASIO_HAS_MOVE)
 
   void operator()()
   {
     dispatcher_.dispatch(handler_);
   }
 
   void operator()() const
   {
     dispatcher_.dispatch(handler_);
   }
 
   template <typename Arg1>
   void operator()(const Arg1& arg1)
   {
     dispatcher_.dispatch(detail::bind_handler(handler_, arg1));
   }
 
   template <typename Arg1>
   void operator()(const Arg1& arg1) const
   {
     dispatcher_.dispatch(detail::bind_handler(handler_, arg1));
   }
 
   template <typename Arg1, typename Arg2>
   void operator()(const Arg1& arg1, const Arg2& arg2)
   {
     dispatcher_.dispatch(detail::bind_handler(handler_, arg1, arg2));
   }
 
   template <typename Arg1, typename Arg2>
   void operator()(const Arg1& arg1, const Arg2& arg2) const
   {
     dispatcher_.dispatch(detail::bind_handler(handler_, arg1, arg2));
   }
 
@@ -108,149 +94,112 @@ public:
   template <typename Arg1, typename Arg2, typename Arg3, typename Arg4>
   void operator()(const Arg1& arg1, const Arg2& arg2, const Arg3& arg3,
       const Arg4& arg4) const
   {
     dispatcher_.dispatch(
         detail::bind_handler(handler_, arg1, arg2, arg3, arg4));
   }
 
   template <typename Arg1, typename Arg2, typename Arg3, typename Arg4,
       typename Arg5>
   void operator()(const Arg1& arg1, const Arg2& arg2, const Arg3& arg3,
       const Arg4& arg4, const Arg5& arg5)
   {
     dispatcher_.dispatch(
         detail::bind_handler(handler_, arg1, arg2, arg3, arg4, arg5));
   }
 
   template <typename Arg1, typename Arg2, typename Arg3, typename Arg4,
       typename Arg5>
   void operator()(const Arg1& arg1, const Arg2& arg2, const Arg3& arg3,
       const Arg4& arg4, const Arg5& arg5) const
   {
     dispatcher_.dispatch(
         detail::bind_handler(handler_, arg1, arg2, arg3, arg4, arg5));
   }
 
 //private:
   Dispatcher dispatcher_;
   Handler handler_;
 };
 
 template <typename Handler, typename Context>
 class rewrapped_handler
 {
 public:
-  explicit rewrapped_handler(Handler& handler, const Context& context)
-    : context_(context),
-      handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler))
-  {
-  }
-
   explicit rewrapped_handler(const Handler& handler, const Context& context)
-    : context_(context),
-      handler_(handler)
-  {
-  }
-
-#if defined(BOOST_ASIO_HAS_MOVE)
-  rewrapped_handler(const rewrapped_handler& other)
-    : context_(other.context_),
-      handler_(other.handler_)
-  {
-  }
-
-  rewrapped_handler(rewrapped_handler&& other)
-    : context_(BOOST_ASIO_MOVE_CAST(Context)(other.context_)),
-      handler_(BOOST_ASIO_MOVE_CAST(Handler)(other.handler_))
+    : handler_(handler),
+      context_(context)
   {
   }
-#endif // defined(BOOST_ASIO_HAS_MOVE)
 
   void operator()()
   {
     handler_();
   }
 
   void operator()() const
   {
     handler_();
   }
 
 //private:
-  Context context_;
   Handler handler_;
+  Context context_;
 };
 
 template <typename Dispatcher, typename Handler>
 inline void* asio_handler_allocate(std::size_t size,
     wrapped_handler<Dispatcher, Handler>* this_handler)
 {
   return boost_asio_handler_alloc_helpers::allocate(
       size, this_handler->handler_);
 }
 
 template <typename Dispatcher, typename Handler>
 inline void asio_handler_deallocate(void* pointer, std::size_t size,
     wrapped_handler<Dispatcher, Handler>* this_handler)
 {
   boost_asio_handler_alloc_helpers::deallocate(
       pointer, size, this_handler->handler_);
 }
 
 template <typename Function, typename Dispatcher, typename Handler>
-inline void asio_handler_invoke(Function& function,
-    wrapped_handler<Dispatcher, Handler>* this_handler)
-{
-  this_handler->dispatcher_.dispatch(
-      rewrapped_handler<Function, Handler>(
-        function, this_handler->handler_));
-}
-
-template <typename Function, typename Dispatcher, typename Handler>
 inline void asio_handler_invoke(const Function& function,
     wrapped_handler<Dispatcher, Handler>* this_handler)
 {
   this_handler->dispatcher_.dispatch(
       rewrapped_handler<Function, Handler>(
         function, this_handler->handler_));
 }
 
 template <typename Handler, typename Context>
 inline void* asio_handler_allocate(std::size_t size,
     rewrapped_handler<Handler, Context>* this_handler)
 {
   return boost_asio_handler_alloc_helpers::allocate(
       size, this_handler->context_);
 }
 
 template <typename Handler, typename Context>
 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 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_);
-}
-
-template <typename Function, typename Handler, typename Context>
 inline void asio_handler_invoke(const Function& function,
     rewrapped_handler<Handler, Context>* this_handler)
 {
   boost_asio_handler_invoke_helpers::invoke(
       function, this_handler->context_);
 }
 
 } // namespace detail
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // BOOST_ASIO_DETAIL_WRAPPED_HANDLER_HPP
diff --git a/3rdParty/Boost/src/boost/asio/error.hpp b/3rdParty/Boost/src/boost/asio/error.hpp
index 331297b..d0287a0 100644
--- a/3rdParty/Boost/src/boost/asio/error.hpp
+++ b/3rdParty/Boost/src/boost/asio/error.hpp
@@ -1,40 +1,40 @@
 //
 // error.hpp
 // ~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_ERROR_HPP
 #define BOOST_ASIO_ERROR_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/cerrno.hpp>
 #include <boost/system/error_code.hpp>
 #if defined(BOOST_WINDOWS) || defined(__CYGWIN__)
 # include <winerror.h>
 #else
 # include <cerrno>
 # include <netdb.h>
 #endif
 
 #if defined(GENERATING_DOCUMENTATION)
 /// INTERNAL ONLY.
 # define BOOST_ASIO_NATIVE_ERROR(e) implementation_defined
 /// INTERNAL ONLY.
 # define BOOST_ASIO_SOCKET_ERROR(e) implementation_defined
 /// 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__)
 # define BOOST_ASIO_NATIVE_ERROR(e) e
@@ -179,149 +179,165 @@ enum netdb_errors
   /// The query is valid but does not have associated address data.
   no_data = BOOST_ASIO_NETDB_ERROR(NO_DATA),
 
   /// A non-recoverable error occurred.
   no_recovery = BOOST_ASIO_NETDB_ERROR(NO_RECOVERY)
 };
 
 enum addrinfo_errors
 {
   /// The service is not supported for the given socket type.
   service_not_found = BOOST_ASIO_WIN_OR_POSIX(
       BOOST_ASIO_NATIVE_ERROR(WSATYPE_NOT_FOUND),
       BOOST_ASIO_GETADDRINFO_ERROR(EAI_SERVICE)),
 
   /// The socket type is not supported.
   socket_type_not_supported = BOOST_ASIO_WIN_OR_POSIX(
       BOOST_ASIO_NATIVE_ERROR(WSAESOCKTNOSUPPORT),
       BOOST_ASIO_GETADDRINFO_ERROR(EAI_SOCKTYPE))
 };
 
 enum misc_errors
 {
   /// Already open.
   already_open = 1,
 
   /// End of file or stream.
   eof,
 
   /// Element not found.
   not_found,
 
   /// The descriptor cannot fit into the select system call's fd_set.
   fd_set_failure
 };
 
+enum ssl_errors
+{
+};
+
 inline const boost::system::error_category& get_system_category()
 {
   return boost::system::system_category();
 }
 
 #if !defined(BOOST_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__)
 
 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__)
 
 extern BOOST_ASIO_DECL
 const boost::system::error_category& get_misc_category();
 
+extern BOOST_ASIO_DECL
+const boost::system::error_category& get_ssl_category();
+
 static const boost::system::error_category& system_category
   = boost::asio::error::get_system_category();
 static const boost::system::error_category& netdb_category
   = boost::asio::error::get_netdb_category();
 static const boost::system::error_category& addrinfo_category
   = boost::asio::error::get_addrinfo_category();
 static const boost::system::error_category& misc_category
   = boost::asio::error::get_misc_category();
+static const boost::system::error_category& ssl_category
+  = boost::asio::error::get_ssl_category();
 
 } // namespace error
 } // namespace asio
-} // namespace boost
 
-namespace boost {
 namespace system {
 
 template<> struct is_error_code_enum<boost::asio::error::basic_errors>
 {
   static const bool value = true;
 };
 
 template<> struct is_error_code_enum<boost::asio::error::netdb_errors>
 {
   static const bool value = true;
 };
 
 template<> struct is_error_code_enum<boost::asio::error::addrinfo_errors>
 {
   static const bool value = true;
 };
 
 template<> struct is_error_code_enum<boost::asio::error::misc_errors>
 {
   static const bool value = true;
 };
 
+template<> struct is_error_code_enum<boost::asio::error::ssl_errors>
+{
+  static const bool value = true;
+};
+
 } // namespace system
-} // namespace boost
 
-namespace boost {
 namespace asio {
 namespace error {
 
 inline boost::system::error_code make_error_code(basic_errors e)
 {
   return boost::system::error_code(
       static_cast<int>(e), get_system_category());
 }
 
 inline boost::system::error_code make_error_code(netdb_errors e)
 {
   return boost::system::error_code(
       static_cast<int>(e), get_netdb_category());
 }
 
 inline boost::system::error_code make_error_code(addrinfo_errors e)
 {
   return boost::system::error_code(
       static_cast<int>(e), get_addrinfo_category());
 }
 
 inline boost::system::error_code make_error_code(misc_errors e)
 {
   return boost::system::error_code(
       static_cast<int>(e), get_misc_category());
 }
 
+inline boost::system::error_code make_error_code(ssl_errors e)
+{
+  return boost::system::error_code(
+      static_cast<int>(e), get_ssl_category());
+}
+
 } // namespace error
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #undef BOOST_ASIO_NATIVE_ERROR
 #undef BOOST_ASIO_SOCKET_ERROR
 #undef BOOST_ASIO_NETDB_ERROR
 #undef BOOST_ASIO_GETADDRINFO_ERROR
 #undef BOOST_ASIO_WIN_OR_POSIX
 
 #if defined(BOOST_ASIO_HEADER_ONLY)
 # include <boost/asio/impl/error.ipp>
 #endif // defined(BOOST_ASIO_HEADER_ONLY)
 
 #endif // BOOST_ASIO_ERROR_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..ca56871 100644
--- a/3rdParty/Boost/src/boost/asio/handler_alloc_hook.hpp
+++ b/3rdParty/Boost/src/boost/asio/handler_alloc_hook.hpp
@@ -1,40 +1,40 @@
 //
 // handler_alloc_hook.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_HANDLER_ALLOC_HOOK_HPP
 #define BOOST_ASIO_HANDLER_ALLOC_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 <cstddef>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 
 /// Default allocation function for handlers.
 /**
  * Asynchronous operations may need to allocate temporary objects. Since
  * 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
  *
  * @note All temporary objects associated with a handler will be deallocated
diff --git a/3rdParty/Boost/src/boost/asio/handler_invoke_hook.hpp b/3rdParty/Boost/src/boost/asio/handler_invoke_hook.hpp
index 6f03888..f4f6831 100644
--- a/3rdParty/Boost/src/boost/asio/handler_invoke_hook.hpp
+++ b/3rdParty/Boost/src/boost/asio/handler_invoke_hook.hpp
@@ -1,40 +1,40 @@
 //
 // handler_invoke_hook.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_HANDLER_INVOKE_HOOK_HPP
 #define BOOST_ASIO_HANDLER_INVOKE_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 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
  * io_service::strand objects) that provide additional guarantees.
  *
  * When asynchronous operations are composed from other asynchronous
  * operations, all intermediate handlers should be invoked using the same
  * method as the final handler. This is required to ensure that user-defined
  * objects are not accessed in a way that may violate the guarantees. This
  * hooking function ensures that the invoked method used for the final handler
  * is accessible at each intermediate step.
diff --git a/3rdParty/Boost/src/boost/asio/impl/connect.hpp b/3rdParty/Boost/src/boost/asio/impl/connect.hpp
deleted file mode 100644
index a21bb2d..0000000
--- a/3rdParty/Boost/src/boost/asio/impl/connect.hpp
+++ /dev/null
@@ -1,391 +0,0 @@
-//
-// impl/connect.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_IMPL_CONNECT_HPP
-#define BOOST_ASIO_IMPL_CONNECT_HPP
-
-#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/consuming_buffers.hpp>
-#include <boost/asio/detail/handler_alloc_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>
-
-namespace boost {
-namespace asio {
-
-namespace detail
-{
-  struct default_connect_condition
-  {
-    template <typename Iterator>
-    Iterator operator()(const boost::system::error_code&, Iterator next)
-    {
-      return next;
-    }
-  };
-}
-
-template <typename Protocol, typename SocketService, typename Iterator>
-Iterator connect(basic_socket<Protocol, SocketService>& s, Iterator begin)
-{
-  boost::system::error_code ec;
-  Iterator result = connect(s, begin, ec);
-  boost::asio::detail::throw_error(ec, "connect");
-  return result;
-}
-
-template <typename Protocol, typename SocketService, typename Iterator>
-inline Iterator connect(basic_socket<Protocol, SocketService>& s,
-    Iterator begin, boost::system::error_code& ec)
-{
-  return connect(s, begin, Iterator(), detail::default_connect_condition(), ec);
-}
-
-template <typename Protocol, typename SocketService, typename Iterator>
-Iterator connect(basic_socket<Protocol, SocketService>& s,
-    Iterator begin, Iterator end)
-{
-  boost::system::error_code ec;
-  Iterator result = connect(s, begin, end, ec);
-  boost::asio::detail::throw_error(ec, "connect");
-  return result;
-}
-
-template <typename Protocol, typename SocketService, typename Iterator>
-inline Iterator connect(basic_socket<Protocol, SocketService>& s,
-    Iterator begin, Iterator end, boost::system::error_code& ec)
-{
-  return connect(s, begin, end, detail::default_connect_condition(), ec);
-}
-
-template <typename Protocol, typename SocketService,
-    typename Iterator, typename ConnectCondition>
-Iterator connect(basic_socket<Protocol, SocketService>& s,
-    Iterator begin, ConnectCondition connect_condition)
-{
-  boost::system::error_code ec;
-  Iterator result = connect(s, begin, connect_condition, ec);
-  boost::asio::detail::throw_error(ec, "connect");
-  return result;
-}
-
-template <typename Protocol, typename SocketService,
-    typename Iterator, typename ConnectCondition>
-inline Iterator connect(basic_socket<Protocol, SocketService>& s,
-    Iterator begin, ConnectCondition connect_condition,
-    boost::system::error_code& ec)
-{
-  return connect(s, begin, Iterator(), connect_condition, ec);
-}
-
-template <typename Protocol, typename SocketService,
-    typename Iterator, typename ConnectCondition>
-Iterator connect(basic_socket<Protocol, SocketService>& s,
-    Iterator begin, Iterator end, ConnectCondition connect_condition)
-{
-  boost::system::error_code ec;
-  Iterator result = connect(s, begin, end, connect_condition, ec);
-  boost::asio::detail::throw_error(ec, "connect");
-  return result;
-}
-
-template <typename Protocol, typename SocketService,
-    typename Iterator, typename ConnectCondition>
-Iterator connect(basic_socket<Protocol, SocketService>& s,
-    Iterator begin, Iterator end, ConnectCondition connect_condition,
-    boost::system::error_code& ec)
-{
-  ec = boost::system::error_code();
-
-  for (Iterator iter = begin; iter != end; ++iter)
-  {
-    iter = connect_condition(ec, iter);
-    if (iter != end)
-    {
-      s.close(ec);
-      s.connect(*iter, ec);
-      if (!ec)
-        return iter;
-    }
-  }
-
-  if (!ec)
-    ec = boost::asio::error::not_found;
-
-  return end;
-}
-
-namespace detail
-{
-  // Enable the empty base class optimisation for the connect condition.
-  template <typename ConnectCondition>
-  class base_from_connect_condition
-  {
-  protected:
-    explicit base_from_connect_condition(
-        const ConnectCondition& connect_condition)
-      : connect_condition_(connect_condition)
-    {
-    }
-
-    template <typename Iterator>
-    void check_condition(const boost::system::error_code& ec,
-        Iterator& iter, Iterator& end)
-    {
-      if (iter != end)
-        iter = connect_condition_(ec, static_cast<const Iterator&>(iter));
-    }
-
-  private:
-    ConnectCondition connect_condition_;
-  };
-
-  // The default_connect_condition implementation is essentially a no-op. This
-  // template specialisation lets us eliminate all costs associated with it.
-  template <>
-  class base_from_connect_condition<default_connect_condition>
-  {
-  protected:
-    explicit base_from_connect_condition(const default_connect_condition&)
-    {
-    }
-
-    template <typename Iterator>
-    void check_condition(const boost::system::error_code&, Iterator&, Iterator&)
-    {
-    }
-  };
-
-  template <typename Protocol, typename SocketService, typename Iterator,
-      typename ConnectCondition, typename ComposedConnectHandler>
-  class connect_op : base_from_connect_condition<ConnectCondition>
-  {
-  public:
-    connect_op(basic_socket<Protocol, SocketService>& sock,
-        const Iterator& begin, const Iterator& end,
-        const ConnectCondition& connect_condition,
-        ComposedConnectHandler& handler)
-      : base_from_connect_condition<ConnectCondition>(connect_condition),
-        socket_(sock),
-        iter_(begin),
-        end_(end),
-        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_),
-        handler_(other.handler_)
-    {
-    }
-
-    connect_op(connect_op&& other)
-      : base_from_connect_condition<ConnectCondition>(other),
-        socket_(other.socket_),
-        iter_(other.iter_),
-        end_(other.end_),
-        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)
-      {
-        case 1:
-        for (;;)
-        {
-          this->check_condition(ec, iter_, end_);
-
-          if (iter_ != end_)
-          {
-            socket_.close(ec);
-            socket_.async_connect(*iter_,
-                BOOST_ASIO_MOVE_CAST(connect_op)(*this));
-            return;
-          }
-
-          if (start)
-          {
-            ec = boost::asio::error::not_found;
-            socket_.get_io_service().post(detail::bind_handler(*this, ec));
-            return;
-          }
-
-          default:
-
-          if (iter_ == end_)
-            break;
-
-          if (!socket_.is_open())
-          {
-            ec = boost::asio::error::operation_aborted;
-            break;
-          }
-
-          if (!ec)
-            break;
-
-          ++iter_;
-        }
-
-        handler_(static_cast<const boost::system::error_code&>(ec),
-            static_cast<const Iterator&>(iter_));
-      }
-    }
-
-  //private:
-    basic_socket<Protocol, SocketService>& socket_;
-    Iterator iter_;
-    Iterator end_;
-    ComposedConnectHandler handler_;
-  };
-
-  template <typename Protocol, typename SocketService, typename Iterator,
-      typename ConnectCondition, typename ComposedConnectHandler>
-  inline void* asio_handler_allocate(std::size_t size,
-      connect_op<Protocol, SocketService, Iterator,
-        ConnectCondition, ComposedConnectHandler>* this_handler)
-  {
-    return boost_asio_handler_alloc_helpers::allocate(
-        size, this_handler->handler_);
-  }
-
-  template <typename Protocol, typename SocketService, typename Iterator,
-      typename ConnectCondition, typename ComposedConnectHandler>
-  inline void asio_handler_deallocate(void* pointer, std::size_t size,
-      connect_op<Protocol, SocketService, Iterator,
-        ConnectCondition, ComposedConnectHandler>* this_handler)
-  {
-    boost_asio_handler_alloc_helpers::deallocate(
-        pointer, size, 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)
-  {
-    boost_asio_handler_invoke_helpers::invoke(
-        function, this_handler->handler_);
-  }
-
-  template <typename Function, typename Protocol,
-      typename SocketService, typename Iterator,
-      typename ConnectCondition, typename ComposedConnectHandler>
-  inline void asio_handler_invoke(const Function& function,
-      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,
-    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);
-}
-
-template <typename Protocol, typename SocketService,
-    typename Iterator, typename ComposedConnectHandler>
-inline void 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);
-}
-
-template <typename Protocol, typename SocketService, typename Iterator,
-    typename ConnectCondition, typename ComposedConnectHandler>
-inline void 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);
-}
-
-template <typename Protocol, typename SocketService, typename Iterator,
-    typename ConnectCondition, typename ComposedConnectHandler>
-void 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);
-}
-
-} // namespace asio
-} // namespace boost
-
-#include <boost/asio/detail/pop_options.hpp>
-
-#endif // BOOST_ASIO_IMPL_CONNECT_HPP
diff --git a/3rdParty/Boost/src/boost/asio/impl/error.ipp b/3rdParty/Boost/src/boost/asio/impl/error.ipp
index cfb7a99..7c045c0 100644
--- a/3rdParty/Boost/src/boost/asio/impl/error.ipp
+++ b/3rdParty/Boost/src/boost/asio/impl/error.ipp
@@ -1,53 +1,55 @@
 //
 // impl/error.ipp
 // ~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_IMPL_ERROR_IPP
 #define BOOST_ASIO_IMPL_ERROR_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/cerrno.hpp>
+#include <boost/system/error_code.hpp>
 #include <boost/asio/error.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace error {
 
 #if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
 
 namespace detail {
 
 class netdb_category : public boost::system::error_category
 {
 public:
   const char* name() const
   {
     return "asio.netdb";
   }
 
   std::string message(int value) const
   {
     if (value == error::host_not_found)
       return "Host not found (authoritative)";
     if (value == error::host_not_found_try_again)
       return "Host not found (non-authoritative), try again later";
     if (value == error::no_data)
       return "The query is valid, but it does not have associated data";
     if (value == error::no_recovery)
       return "A non-recoverable error occurred during database lookup";
     return "asio.netdb error";
   }
 };
 
 } // namespace detail
@@ -88,42 +90,66 @@ const boost::system::error_category& get_addrinfo_category()
 
 #endif // !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
 
 namespace detail {
 
 class misc_category : public boost::system::error_category
 {
 public:
   const char* name() const
   {
     return "asio.misc";
   }
 
   std::string message(int value) const
   {
     if (value == error::already_open)
       return "Already open";
     if (value == error::eof)
       return "End of file";
     if (value == error::not_found)
       return "Element not found";
     if (value == error::fd_set_failure)
       return "The descriptor does not fit into the select call's fd_set";
     return "asio.misc error";
   }
 };
 
 } // namespace detail
 
 const boost::system::error_category& get_misc_category()
 {
   static detail::misc_category instance;
   return instance;
 }
 
+namespace detail {
+
+class ssl_category : public boost::system::error_category
+{
+public:
+  const char* name() const
+  {
+    return "asio.ssl";
+  }
+
+  std::string message(int) const
+  {
+    return "asio.ssl error";
+  }
+};
+
+} // namespace detail
+
+const boost::system::error_category& get_ssl_category()
+{
+  static detail::ssl_category instance;
+  return instance;
+}
+
 } // namespace error
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // BOOST_ASIO_IMPL_ERROR_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..152f983 100644
--- a/3rdParty/Boost/src/boost/asio/impl/io_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/impl/io_service.hpp
@@ -1,143 +1,136 @@
 //
 // impl/io_service.hpp
 // ~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_IMPL_IO_SERVICE_HPP
 #define BOOST_ASIO_IMPL_IO_SERVICE_HPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
-#include <boost/asio/detail/handler_type_requirements.hpp>
 #include <boost/asio/detail/service_registry.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 
 template <typename Service>
 inline Service& use_service(io_service& ios)
 {
   // Check that Service meets the necessary type requirements.
   (void)static_cast<io_service::service*>(static_cast<Service*>(0));
   (void)static_cast<const io_service::id*>(&Service::id);
 
   return ios.service_registry_->template use_service<Service>();
 }
 
-template <>
-inline detail::io_service_impl& use_service<detail::io_service_impl>(
-    io_service& ios)
-{
-  return ios.impl_;
-}
-
 template <typename Service>
 inline void add_service(io_service& ios, Service* svc)
 {
   // Check that Service meets the necessary type requirements.
   (void)static_cast<io_service::service*>(static_cast<Service*>(0));
   (void)static_cast<const io_service::id*>(&Service::id);
 
   ios.service_registry_->template add_service<Service>(svc);
 }
 
 template <typename Service>
 inline bool has_service(io_service& ios)
 {
   // Check that Service meets the necessary type requirements.
   (void)static_cast<io_service::service*>(static_cast<Service*>(0));
   (void)static_cast<const io_service::id*>(&Service::id);
 
   return ios.service_registry_->template has_service<Service>();
 }
 
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #if defined(BOOST_ASIO_HAS_IOCP)
 # include <boost/asio/detail/win_iocp_io_service.hpp>
 #else
 # include <boost/asio/detail/task_io_service.hpp>
 #endif
 
 #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)
+template <typename Handler>
+inline void io_service::dispatch(Handler 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));
+  impl_.dispatch(handler);
 }
 
-template <typename CompletionHandler>
-inline void io_service::post(BOOST_ASIO_MOVE_ARG(CompletionHandler) handler)
+template <typename Handler>
+inline void io_service::post(Handler 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));
+  impl_.post(handler);
 }
 
 template <typename Handler>
 #if defined(GENERATING_DOCUMENTATION)
 unspecified
 #else
 inline detail::wrapped_handler<io_service&, Handler>
 #endif
 io_service::wrap(Handler handler)
 {
   return detail::wrapped_handler<io_service&, Handler>(*this, handler);
 }
 
 inline io_service::work::work(boost::asio::io_service& io_service)
-  : io_service_impl_(io_service.impl_)
+  : io_service_(io_service)
 {
-  io_service_impl_.work_started();
+  io_service_.impl_.work_started();
 }
 
 inline io_service::work::work(const work& other)
-  : io_service_impl_(other.io_service_impl_)
+  : io_service_(other.io_service_)
 {
-  io_service_impl_.work_started();
+  io_service_.impl_.work_started();
 }
 
 inline io_service::work::~work()
 {
-  io_service_impl_.work_finished();
+  io_service_.impl_.work_finished();
+}
+
+inline boost::asio::io_service& io_service::work::io_service()
+{
+  return io_service_;
 }
 
 inline boost::asio::io_service& io_service::work::get_io_service()
 {
-  return io_service_impl_.get_io_service();
+  return io_service_;
+}
+
+inline boost::asio::io_service& io_service::service::io_service()
+{
+  return owner_;
 }
 
 inline boost::asio::io_service& io_service::service::get_io_service()
 {
   return owner_;
 }
 
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // BOOST_ASIO_IMPL_IO_SERVICE_HPP
diff --git a/3rdParty/Boost/src/boost/asio/impl/io_service.ipp b/3rdParty/Boost/src/boost/asio/impl/io_service.ipp
index 1e3af48..a0b34af 100644
--- a/3rdParty/Boost/src/boost/asio/impl/io_service.ipp
+++ b/3rdParty/Boost/src/boost/asio/impl/io_service.ipp
@@ -1,157 +1,141 @@
 //
 // impl/io_service.ipp
 // ~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_IMPL_IO_SERVICE_IPP
 #define BOOST_ASIO_IMPL_IO_SERVICE_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/limits.hpp>
 #include <boost/asio/io_service.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>
 #else
 # include <boost/asio/detail/task_io_service.hpp>
 #endif
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 
 io_service::io_service()
-  : service_registry_(new boost::asio::detail::service_registry(
-        *this, static_cast<impl_type*>(0),
-        (std::numeric_limits<std::size_t>::max)())),
-    impl_(service_registry_->first_service<impl_type>())
+  : service_registry_(new boost::asio::detail::service_registry(*this)),
+    impl_(service_registry_->use_service<impl_type>())
 {
+  impl_.init((std::numeric_limits<std::size_t>::max)());
 }
 
 io_service::io_service(std::size_t concurrency_hint)
-  : service_registry_(new boost::asio::detail::service_registry(
-        *this, static_cast<impl_type*>(0), concurrency_hint)),
-    impl_(service_registry_->first_service<impl_type>())
+  : service_registry_(new boost::asio::detail::service_registry(*this)),
+    impl_(service_registry_->use_service<impl_type>())
 {
+  impl_.init(concurrency_hint);
 }
 
 io_service::~io_service()
 {
   delete service_registry_;
 }
 
 std::size_t io_service::run()
 {
   boost::system::error_code ec;
   std::size_t s = impl_.run(ec);
   boost::asio::detail::throw_error(ec);
   return s;
 }
 
 std::size_t io_service::run(boost::system::error_code& ec)
 {
   return impl_.run(ec);
 }
 
 std::size_t io_service::run_one()
 {
   boost::system::error_code ec;
   std::size_t s = impl_.run_one(ec);
   boost::asio::detail::throw_error(ec);
   return s;
 }
 
 std::size_t io_service::run_one(boost::system::error_code& ec)
 {
   return impl_.run_one(ec);
 }
 
 std::size_t io_service::poll()
 {
   boost::system::error_code ec;
   std::size_t s = impl_.poll(ec);
   boost::asio::detail::throw_error(ec);
   return s;
 }
 
 std::size_t io_service::poll(boost::system::error_code& ec)
 {
   return impl_.poll(ec);
 }
 
 std::size_t io_service::poll_one()
 {
   boost::system::error_code ec;
   std::size_t s = impl_.poll_one(ec);
   boost::asio::detail::throw_error(ec);
   return s;
 }
 
 std::size_t io_service::poll_one(boost::system::error_code& ec)
 {
   return impl_.poll_one(ec);
 }
 
 void io_service::stop()
 {
   impl_.stop();
 }
 
-bool io_service::stopped() const
-{
-  return impl_.stopped();
-}
-
 void io_service::reset()
 {
   impl_.reset();
 }
 
-void io_service::notify_fork(boost::asio::io_service::fork_event event)
-{
-  service_registry_->notify_fork(event);
-}
-
 io_service::service::service(boost::asio::io_service& owner)
   : owner_(owner),
     next_(0)
 {
 }
 
 io_service::service::~service()
 {
 }
 
-void io_service::service::fork_service(boost::asio::io_service::fork_event)
-{
-}
-
 service_already_exists::service_already_exists()
   : std::logic_error("Service already exists.")
 {
 }
 
 invalid_service_owner::invalid_service_owner()
   : std::logic_error("Invalid service owner.")
 {
 }
 
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // BOOST_ASIO_IMPL_IO_SERVICE_IPP
diff --git a/3rdParty/Boost/src/boost/asio/impl/read.hpp b/3rdParty/Boost/src/boost/asio/impl/read.hpp
index 9290cd4..9fba190 100644
--- a/3rdParty/Boost/src/boost/asio/impl/read.hpp
+++ b/3rdParty/Boost/src/boost/asio/impl/read.hpp
@@ -1,696 +1,388 @@
 //
 // impl/read.hpp
 // ~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_IMPL_READ_HPP
 #define BOOST_ASIO_IMPL_READ_HPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <algorithm>
 #include <boost/asio/buffer.hpp>
 #include <boost/asio/completion_condition.hpp>
-#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_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>
 
 namespace boost {
 namespace asio {
 
 template <typename SyncReadStream, typename MutableBufferSequence,
     typename CompletionCondition>
 std::size_t read(SyncReadStream& s, 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;
   tmp.prepare(detail::adapt_completion_condition_result(
         completion_condition(ec, total_transferred)));
   while (tmp.begin() != tmp.end())
   {
     std::size_t bytes_transferred = s.read_some(tmp, ec);
     tmp.consume(bytes_transferred);
     total_transferred += bytes_transferred;
     tmp.prepare(detail::adapt_completion_condition_result(
           completion_condition(ec, total_transferred)));
   }
   return total_transferred;
 }
 
 template <typename SyncReadStream, typename MutableBufferSequence>
 inline std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers)
 {
   boost::system::error_code ec;
   std::size_t bytes_transferred = read(s, buffers, transfer_all(), ec);
-  boost::asio::detail::throw_error(ec, "read");
+  boost::asio::detail::throw_error(ec);
   return bytes_transferred;
 }
 
-template <typename SyncReadStream, typename MutableBufferSequence>
-inline std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
-    boost::system::error_code& ec)
-{
-  return read(s, buffers, transfer_all(), ec);
-}
-
 template <typename SyncReadStream, typename MutableBufferSequence,
     typename CompletionCondition>
 inline std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
     CompletionCondition completion_condition)
 {
   boost::system::error_code ec;
   std::size_t bytes_transferred = read(s, buffers, completion_condition, ec);
-  boost::asio::detail::throw_error(ec, "read");
+  boost::asio::detail::throw_error(ec);
   return bytes_transferred;
 }
 
 #if !defined(BOOST_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)
 {
   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));
   std::size_t bytes_available = read_size_helper(b, max_size);
   while (bytes_available > 0)
   {
     std::size_t bytes_transferred = s.read_some(b.prepare(bytes_available), ec);
     b.commit(bytes_transferred);
     total_transferred += bytes_transferred;
     max_size = detail::adapt_completion_condition_result(
           completion_condition(ec, total_transferred));
     bytes_available = read_size_helper(b, max_size);
   }
   return total_transferred;
 }
 
 template <typename SyncReadStream, typename Allocator>
 inline std::size_t read(SyncReadStream& s,
     boost::asio::basic_streambuf<Allocator>& b)
 {
   boost::system::error_code ec;
   std::size_t bytes_transferred = read(s, b, transfer_all(), ec);
-  boost::asio::detail::throw_error(ec, "read");
+  boost::asio::detail::throw_error(ec);
   return bytes_transferred;
 }
 
-template <typename SyncReadStream, typename Allocator>
-inline std::size_t read(SyncReadStream& s,
-    boost::asio::basic_streambuf<Allocator>& b,
-    boost::system::error_code& ec)
-{
-  return read(s, b, transfer_all(), ec);
-}
-
 template <typename SyncReadStream, typename Allocator,
     typename CompletionCondition>
 inline std::size_t read(SyncReadStream& s,
     boost::asio::basic_streambuf<Allocator>& b,
     CompletionCondition completion_condition)
 {
   boost::system::error_code ec;
   std::size_t bytes_transferred = read(s, b, completion_condition, ec);
-  boost::asio::detail::throw_error(ec, "read");
+  boost::asio::detail::throw_error(ec);
   return bytes_transferred;
 }
 
 #endif // !defined(BOOST_NO_IOSTREAM)
 
 namespace detail
 {
   template <typename AsyncReadStream, typename MutableBufferSequence,
       typename CompletionCondition, typename ReadHandler>
   class read_op
     : detail::base_from_completion_cond<CompletionCondition>
   {
   public:
     read_op(AsyncReadStream& stream, const MutableBufferSequence& buffers,
-        CompletionCondition completion_condition, ReadHandler& handler)
+        CompletionCondition completion_condition, ReadHandler handler)
       : detail::base_from_completion_cond<
           CompletionCondition>(completion_condition),
         stream_(stream),
         buffers_(buffers),
         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_),
-        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_),
-        total_transferred_(other.total_transferred_),
-        handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(other.handler_))
+        handler_(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)
       {
         case 1:
         buffers_.prepare(this->check_for_completion(ec, total_transferred_));
         for (;;)
         {
-          stream_.async_read_some(buffers_,
-              BOOST_ASIO_MOVE_CAST(read_op)(*this));
+          stream_.async_read_some(buffers_, *this);
           return; default:
           total_transferred_ += bytes_transferred;
           buffers_.consume(bytes_transferred);
           buffers_.prepare(this->check_for_completion(ec, total_transferred_));
           if ((!ec && bytes_transferred == 0)
               || buffers_.begin() == buffers_.end())
             break;
         }
 
         handler_(ec, static_cast<const std::size_t&>(total_transferred_));
       }
     }
 
   //private:
     AsyncReadStream& stream_;
     boost::asio::detail::consuming_buffers<
       mutable_buffer, MutableBufferSequence> buffers_;
     std::size_t total_transferred_;
     ReadHandler handler_;
   };
 
   template <typename AsyncReadStream,
       typename CompletionCondition, typename ReadHandler>
   class read_op<AsyncReadStream, boost::asio::mutable_buffers_1,
       CompletionCondition, ReadHandler>
     : detail::base_from_completion_cond<CompletionCondition>
   {
   public:
     read_op(AsyncReadStream& stream,
         const boost::asio::mutable_buffers_1& buffers,
-        CompletionCondition completion_condition, ReadHandler& handler)
+        CompletionCondition completion_condition,
+        ReadHandler handler)
       : detail::base_from_completion_cond<
           CompletionCondition>(completion_condition),
         stream_(stream),
         buffer_(buffers),
         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_),
-        total_transferred_(other.total_transferred_),
-        handler_(other.handler_)
+        handler_(handler)
     {
     }
 
-    read_op(read_op&& other)
-      : detail::base_from_completion_cond<CompletionCondition>(other),
-        stream_(other.stream_),
-        buffer_(other.buffer_),
-        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)
       {
         case 1:
         n = this->check_for_completion(ec, total_transferred_);
         for (;;)
         {
-          stream_.async_read_some(
-              boost::asio::buffer(buffer_ + total_transferred_, n),
-              BOOST_ASIO_MOVE_CAST(read_op)(*this));
+          stream_.async_read_some(boost::asio::buffer(
+                buffer_ + total_transferred_, n), *this);
           return; default:
           total_transferred_ += bytes_transferred;
           if ((!ec && bytes_transferred == 0)
               || (n = this->check_for_completion(ec, total_transferred_)) == 0
               || total_transferred_ == boost::asio::buffer_size(buffer_))
             break;
         }
 
         handler_(ec, static_cast<const std::size_t&>(total_transferred_));
       }
     }
 
   //private:
     AsyncReadStream& stream_;
     boost::asio::mutable_buffer buffer_;
     std::size_t total_transferred_;
     ReadHandler handler_;
   };
 
-  template <typename AsyncReadStream, typename Elem,
-      typename CompletionCondition, typename ReadHandler>
-  class read_op<AsyncReadStream, boost::array<Elem, 2>,
-      CompletionCondition, ReadHandler>
-    : detail::base_from_completion_cond<CompletionCondition>
-  {
-  public:
-    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),
-        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_),
-        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_),
-        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)
-    {
-      typename boost::asio::detail::dependent_type<Elem,
-          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)
-      {
-        case 1:
-        n = this->check_for_completion(ec, total_transferred_);
-        for (;;)
-        {
-          bufs[0] = boost::asio::buffer(bufs[0] + total_transferred_, n);
-          bufs[1] = boost::asio::buffer(
-              bufs[1] + (total_transferred_ < buffer_size0
-                ? 0 : total_transferred_ - buffer_size0),
-              n - boost::asio::buffer_size(bufs[0]));
-          stream_.async_read_some(bufs, BOOST_ASIO_MOVE_CAST(read_op)(*this));
-          return; default:
-          total_transferred_ += bytes_transferred;
-          if ((!ec && bytes_transferred == 0)
-              || (n = this->check_for_completion(ec, total_transferred_)) == 0
-              || total_transferred_ == buffer_size0 + buffer_size1)
-            break;
-        }
-
-        handler_(ec, static_cast<const std::size_t&>(total_transferred_));
-      }
-    }
-
-  //private:
-    AsyncReadStream& stream_;
-    boost::array<Elem, 2> buffers_;
-    std::size_t total_transferred_;
-    ReadHandler handler_;
-  };
-
-#if defined(BOOST_ASIO_HAS_STD_ARRAY)
-
-  template <typename AsyncReadStream, typename Elem,
-      typename CompletionCondition, typename ReadHandler>
-  class read_op<AsyncReadStream, std::array<Elem, 2>,
-      CompletionCondition, ReadHandler>
-    : detail::base_from_completion_cond<CompletionCondition>
-  {
-  public:
-    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),
-        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_),
-        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_),
-        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)
-    {
-      typename boost::asio::detail::dependent_type<Elem,
-          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)
-      {
-        case 1:
-        n = this->check_for_completion(ec, total_transferred_);
-        for (;;)
-        {
-          bufs[0] = boost::asio::buffer(bufs[0] + total_transferred_, n);
-          bufs[1] = boost::asio::buffer(
-              bufs[1] + (total_transferred_ < buffer_size0
-                ? 0 : total_transferred_ - buffer_size0),
-              n - boost::asio::buffer_size(bufs[0]));
-          stream_.async_read_some(bufs, BOOST_ASIO_MOVE_CAST(read_op)(*this));
-          return; default:
-          total_transferred_ += bytes_transferred;
-          if ((!ec && bytes_transferred == 0)
-              || (n = this->check_for_completion(ec, total_transferred_)) == 0
-              || total_transferred_ == buffer_size0 + buffer_size1)
-            break;
-        }
-
-        handler_(ec, static_cast<const std::size_t&>(total_transferred_));
-      }
-    }
-
-  //private:
-    AsyncReadStream& stream_;
-    std::array<Elem, 2> buffers_;
-    std::size_t total_transferred_;
-    ReadHandler handler_;
-  };
-
-#endif // defined(BOOST_ASIO_HAS_STD_ARRAY)
-
   template <typename AsyncReadStream, typename MutableBufferSequence,
       typename CompletionCondition, typename ReadHandler>
   inline void* asio_handler_allocate(std::size_t size,
       read_op<AsyncReadStream, MutableBufferSequence,
         CompletionCondition, ReadHandler>* this_handler)
   {
     return boost_asio_handler_alloc_helpers::allocate(
         size, this_handler->handler_);
   }
 
   template <typename AsyncReadStream, typename MutableBufferSequence,
       typename CompletionCondition, typename ReadHandler>
   inline void asio_handler_deallocate(void* pointer, std::size_t size,
       read_op<AsyncReadStream, MutableBufferSequence,
         CompletionCondition, ReadHandler>* this_handler)
   {
     boost_asio_handler_alloc_helpers::deallocate(
         pointer, size, 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)
-  {
-    boost_asio_handler_invoke_helpers::invoke(
-        function, this_handler->handler_);
-  }
-
-  template <typename Function, typename AsyncReadStream,
-      typename MutableBufferSequence, typename CompletionCondition,
-      typename ReadHandler>
   inline void asio_handler_invoke(const Function& function,
       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,
-    CompletionCondition completion_condition,
-    BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+    CompletionCondition completion_condition, 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))(
+  detail::read_op<AsyncReadStream, MutableBufferSequence,
+    CompletionCondition, ReadHandler>(
+      s, buffers, completion_condition, handler)(
         boost::system::error_code(), 0, 1);
 }
 
 template <typename AsyncReadStream, typename MutableBufferSequence,
     typename ReadHandler>
 inline void async_read(AsyncReadStream& s, const MutableBufferSequence& buffers,
-    BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+    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);
+  async_read(s, buffers, transfer_all(), handler);
 }
 
 #if !defined(BOOST_NO_IOSTREAM)
 
 namespace detail
 {
   template <typename AsyncReadStream, typename Allocator,
       typename CompletionCondition, typename ReadHandler>
   class read_streambuf_op
     : detail::base_from_completion_cond<CompletionCondition>
   {
   public:
     read_streambuf_op(AsyncReadStream& stream,
         basic_streambuf<Allocator>& streambuf,
-        CompletionCondition completion_condition, ReadHandler& handler)
+        CompletionCondition completion_condition, ReadHandler handler)
       : detail::base_from_completion_cond<
           CompletionCondition>(completion_condition),
         stream_(stream),
         streambuf_(streambuf),
         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_),
-        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_),
-        total_transferred_(other.total_transferred_),
-        handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(other.handler_))
+        handler_(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)
       {
         case 1:
         max_size = this->check_for_completion(ec, total_transferred_);
         bytes_available = read_size_helper(streambuf_, max_size);
         for (;;)
         {
-          stream_.async_read_some(streambuf_.prepare(bytes_available),
-              BOOST_ASIO_MOVE_CAST(read_streambuf_op)(*this));
+          stream_.async_read_some(streambuf_.prepare(bytes_available), *this);
           return; default:
           total_transferred_ += bytes_transferred;
           streambuf_.commit(bytes_transferred);
           max_size = this->check_for_completion(ec, total_transferred_);
           bytes_available = read_size_helper(streambuf_, max_size);
           if ((!ec && bytes_transferred == 0) || bytes_available == 0)
             break;
         }
 
         handler_(ec, static_cast<const std::size_t&>(total_transferred_));
       }
     }
 
   //private:
     AsyncReadStream& stream_;
     boost::asio::basic_streambuf<Allocator>& streambuf_;
     std::size_t total_transferred_;
     ReadHandler handler_;
   };
 
   template <typename AsyncReadStream, typename Allocator,
       typename CompletionCondition, typename ReadHandler>
   inline void* asio_handler_allocate(std::size_t size,
       read_streambuf_op<AsyncReadStream, Allocator,
         CompletionCondition, ReadHandler>* this_handler)
   {
     return boost_asio_handler_alloc_helpers::allocate(
         size, this_handler->handler_);
   }
 
   template <typename AsyncReadStream, typename Allocator,
       typename CompletionCondition, typename ReadHandler>
   inline void asio_handler_deallocate(void* pointer, std::size_t size,
       read_streambuf_op<AsyncReadStream, Allocator,
         CompletionCondition, ReadHandler>* this_handler)
   {
     boost_asio_handler_alloc_helpers::deallocate(
         pointer, size, 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)
-  {
-    boost_asio_handler_invoke_helpers::invoke(
-        function, this_handler->handler_);
-  }
-
-  template <typename Function, typename AsyncReadStream,
-      typename Allocator, typename CompletionCondition, typename ReadHandler>
   inline void asio_handler_invoke(const Function& function,
       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,
     boost::asio::basic_streambuf<Allocator>& b,
-    CompletionCondition completion_condition,
-    BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+    CompletionCondition completion_condition, 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::read_streambuf_op<AsyncReadStream,
+    Allocator, CompletionCondition, ReadHandler>(
+      s, b, completion_condition, handler)(
+        boost::system::error_code(), 0, 1);
 }
 
 template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
 inline void async_read(AsyncReadStream& s,
-    boost::asio::basic_streambuf<Allocator>& b,
-    BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+    boost::asio::basic_streambuf<Allocator>& b, 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);
+  async_read(s, b, transfer_all(), handler);
 }
 
 #endif // !defined(BOOST_NO_IOSTREAM)
 
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // BOOST_ASIO_IMPL_READ_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..dcf2c33 100644
--- a/3rdParty/Boost/src/boost/asio/impl/read_at.hpp
+++ b/3rdParty/Boost/src/boost/asio/impl/read_at.hpp
@@ -1,745 +1,412 @@
 //
 // impl/read_at.hpp
 // ~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_IMPL_READ_AT_HPP
 #define BOOST_ASIO_IMPL_READ_AT_HPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <algorithm>
 #include <boost/asio/buffer.hpp>
 #include <boost/asio/completion_condition.hpp>
-#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_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>
 
 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,
     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;
   tmp.prepare(detail::adapt_completion_condition_result(
         completion_condition(ec, total_transferred)));
   while (tmp.begin() != tmp.end())
   {
     std::size_t bytes_transferred = d.read_some_at(
         offset + total_transferred, tmp, ec);
     tmp.consume(bytes_transferred);
     total_transferred += bytes_transferred;
     tmp.prepare(detail::adapt_completion_condition_result(
           completion_condition(ec, total_transferred)));
   }
   return total_transferred;
 }
 
 template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence>
 inline std::size_t read_at(SyncRandomAccessReadDevice& d,
     boost::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");
+  boost::asio::detail::throw_error(ec);
   return bytes_transferred;
 }
 
-template <typename SyncRandomAccessReadDevice, typename MutableBufferSequence>
-inline std::size_t read_at(SyncRandomAccessReadDevice& d,
-    boost::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,
     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");
+  boost::asio::detail::throw_error(ec);
   return bytes_transferred;
 }
 
 #if !defined(BOOST_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,
     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));
   std::size_t bytes_available = read_size_helper(b, max_size);
   while (bytes_available > 0)
   {
     std::size_t bytes_transferred = d.read_some_at(
         offset + total_transferred, b.prepare(bytes_available), ec);
     b.commit(bytes_transferred);
     total_transferred += bytes_transferred;
     max_size = detail::adapt_completion_condition_result(
           completion_condition(ec, total_transferred));
     bytes_available = read_size_helper(b, max_size);
   }
   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)
 {
   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");
+  boost::asio::detail::throw_error(ec);
   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,
-    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,
     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");
+  boost::asio::detail::throw_error(ec);
   return bytes_transferred;
 }
 
 #endif // !defined(BOOST_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,
-        CompletionCondition completion_condition, ReadHandler& handler)
+        CompletionCondition completion_condition, ReadHandler handler)
       : detail::base_from_completion_cond<
           CompletionCondition>(completion_condition),
         device_(device),
         offset_(offset),
         buffers_(buffers),
         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_),
-        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_),
-        total_transferred_(other.total_transferred_),
-        handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(other.handler_))
+        handler_(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)
       {
         case 1:
         buffers_.prepare(this->check_for_completion(ec, total_transferred_));
         for (;;)
         {
-          device_.async_read_some_at(offset_ + total_transferred_,
-              buffers_, BOOST_ASIO_MOVE_CAST(read_at_op)(*this));
+          device_.async_read_some_at(
+              offset_ + total_transferred_, buffers_, *this);
           return; default:
           total_transferred_ += bytes_transferred;
           buffers_.consume(bytes_transferred);
           buffers_.prepare(this->check_for_completion(ec, total_transferred_));
           if ((!ec && bytes_transferred == 0)
               || buffers_.begin() == buffers_.end())
             break;
         }
 
         handler_(ec, static_cast<const std::size_t&>(total_transferred_));
       }
     }
 
   //private:
     AsyncRandomAccessReadDevice& device_;
     boost::uint64_t offset_;
     boost::asio::detail::consuming_buffers<
       mutable_buffer, MutableBufferSequence> buffers_;
     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,
-        CompletionCondition completion_condition, ReadHandler& handler)
+        CompletionCondition completion_condition, ReadHandler handler)
       : detail::base_from_completion_cond<
           CompletionCondition>(completion_condition),
         device_(device),
         offset_(offset),
         buffer_(buffers),
         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_),
-        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_),
-        total_transferred_(other.total_transferred_),
-        handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(other.handler_))
+        handler_(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)
       {
         case 1:
         n = this->check_for_completion(ec, total_transferred_);
         for (;;)
         {
           device_.async_read_some_at(offset_ + total_transferred_,
-              boost::asio::buffer(buffer_ + total_transferred_, n),
-              BOOST_ASIO_MOVE_CAST(read_at_op)(*this));
+              boost::asio::buffer(buffer_ + total_transferred_, n), *this);
           return; default:
           total_transferred_ += bytes_transferred;
           if ((!ec && bytes_transferred == 0)
               || (n = this->check_for_completion(ec, total_transferred_)) == 0
               || total_transferred_ == boost::asio::buffer_size(buffer_))
             break;
         }
 
         handler_(ec, static_cast<const std::size_t&>(total_transferred_));
       }
     }
 
   //private:
     AsyncRandomAccessReadDevice& device_;
     boost::uint64_t offset_;
     boost::asio::mutable_buffer buffer_;
     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,
-        CompletionCondition completion_condition, ReadHandler& handler)
-      : detail::base_from_completion_cond<
-          CompletionCondition>(completion_condition),
-        device_(device),
-        offset_(offset),
-        buffers_(buffers),
-        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_),
-        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_),
-        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)
-    {
-      typename boost::asio::detail::dependent_type<Elem,
-          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)
-      {
-        case 1:
-        n = this->check_for_completion(ec, total_transferred_);
-        for (;;)
-        {
-          bufs[0] = boost::asio::buffer(bufs[0] + total_transferred_, n);
-          bufs[1] = boost::asio::buffer(
-              bufs[1] + (total_transferred_ < buffer_size0
-                ? 0 : total_transferred_ - buffer_size0),
-              n - boost::asio::buffer_size(bufs[0]));
-          device_.async_read_some_at(offset_ + total_transferred_,
-              bufs, BOOST_ASIO_MOVE_CAST(read_at_op)(*this));
-          return; default:
-          total_transferred_ += bytes_transferred;
-          if ((!ec && bytes_transferred == 0)
-              || (n = this->check_for_completion(ec, total_transferred_)) == 0
-              || total_transferred_ == buffer_size0 + buffer_size1)
-            break;
-        }
-
-        handler_(ec, static_cast<const std::size_t&>(total_transferred_));
-      }
-    }
-
-  //private:
-    AsyncRandomAccessReadDevice& device_;
-    boost::uint64_t offset_;
-    boost::array<Elem, 2> buffers_;
-    std::size_t total_transferred_;
-    ReadHandler handler_;
-  };
-
-#if defined(BOOST_ASIO_HAS_STD_ARRAY)
-
-  template <typename AsyncRandomAccessReadDevice, typename Elem,
-      typename CompletionCondition, typename ReadHandler>
-  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,
-        CompletionCondition completion_condition, ReadHandler& handler)
-      : detail::base_from_completion_cond<
-          CompletionCondition>(completion_condition),
-        device_(device),
-        offset_(offset),
-        buffers_(buffers),
-        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_),
-        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_),
-        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)
-    {
-      typename boost::asio::detail::dependent_type<Elem,
-          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)
-      {
-        case 1:
-        n = this->check_for_completion(ec, total_transferred_);
-        for (;;)
-        {
-          bufs[0] = boost::asio::buffer(bufs[0] + total_transferred_, n);
-          bufs[1] = boost::asio::buffer(
-              bufs[1] + (total_transferred_ < buffer_size0
-                ? 0 : total_transferred_ - buffer_size0),
-              n - boost::asio::buffer_size(bufs[0]));
-          device_.async_read_some_at(offset_ + total_transferred_,
-              bufs, BOOST_ASIO_MOVE_CAST(read_at_op)(*this));
-          return; default:
-          total_transferred_ += bytes_transferred;
-          if ((!ec && bytes_transferred == 0)
-              || (n = this->check_for_completion(ec, total_transferred_)) == 0
-              || total_transferred_ == buffer_size0 + buffer_size1)
-            break;
-        }
-
-        handler_(ec, static_cast<const std::size_t&>(total_transferred_));
-      }
-    }
-
-  //private:
-    AsyncRandomAccessReadDevice& device_;
-    boost::uint64_t offset_;
-    std::array<Elem, 2> buffers_;
-    std::size_t total_transferred_;
-    ReadHandler handler_;
-  };
-
-#endif // defined(BOOST_ASIO_HAS_STD_ARRAY)
-
   template <typename AsyncRandomAccessReadDevice,
       typename MutableBufferSequence, typename CompletionCondition,
       typename ReadHandler>
   inline void* asio_handler_allocate(std::size_t size,
       read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence,
         CompletionCondition, ReadHandler>* this_handler)
   {
     return boost_asio_handler_alloc_helpers::allocate(
         size, this_handler->handler_);
   }
 
   template <typename AsyncRandomAccessReadDevice,
       typename MutableBufferSequence, typename CompletionCondition,
       typename ReadHandler>
   inline void asio_handler_deallocate(void* pointer, std::size_t size,
       read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence,
         CompletionCondition, ReadHandler>* this_handler)
   {
     boost_asio_handler_alloc_helpers::deallocate(
         pointer, size, 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)
-  {
-    boost_asio_handler_invoke_helpers::invoke(
-        function, this_handler->handler_);
-  }
-
-  template <typename Function, typename AsyncRandomAccessReadDevice,
-      typename MutableBufferSequence, typename CompletionCondition,
-      typename ReadHandler>
   inline void asio_handler_invoke(const Function& function,
       read_at_op<AsyncRandomAccessReadDevice, MutableBufferSequence,
         CompletionCondition, ReadHandler>* this_handler)
   {
     boost_asio_handler_invoke_helpers::invoke(
         function, this_handler->handler_);
   }
-
-  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,
-      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,
-    CompletionCondition completion_condition,
-    BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+    CompletionCondition completion_condition, 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))(
+  detail::read_at_op<AsyncRandomAccessReadDevice,
+    MutableBufferSequence, CompletionCondition, ReadHandler>(
+      d, offset, buffers, completion_condition, handler)(
         boost::system::error_code(), 0, 1);
 }
 
 template <typename AsyncRandomAccessReadDevice, typename MutableBufferSequence,
     typename ReadHandler>
 inline void async_read_at(AsyncRandomAccessReadDevice& d,
     boost::uint64_t offset, const MutableBufferSequence& buffers,
-    BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+    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);
+  async_read_at(d, offset, buffers, transfer_all(), handler);
 }
 
 #if !defined(BOOST_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,
-        CompletionCondition completion_condition, ReadHandler& handler)
+        CompletionCondition completion_condition, ReadHandler handler)
       : detail::base_from_completion_cond<
           CompletionCondition>(completion_condition),
         device_(device),
         offset_(offset),
         streambuf_(streambuf),
         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_),
-        total_transferred_(other.total_transferred_),
-        handler_(other.handler_)
+        handler_(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_),
-        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)
       {
         case 1:
         max_size = this->check_for_completion(ec, total_transferred_);
         bytes_available = read_size_helper(streambuf_, max_size);
         for (;;)
         {
           device_.async_read_some_at(offset_ + total_transferred_,
-              streambuf_.prepare(bytes_available),
-              BOOST_ASIO_MOVE_CAST(read_at_streambuf_op)(*this));
+              streambuf_.prepare(bytes_available), *this);
           return; default:
           total_transferred_ += bytes_transferred;
           streambuf_.commit(bytes_transferred);
           max_size = this->check_for_completion(ec, total_transferred_);
           bytes_available = read_size_helper(streambuf_, max_size);
           if ((!ec && bytes_transferred == 0) || bytes_available == 0)
             break;
         }
 
         handler_(ec, static_cast<const std::size_t&>(total_transferred_));
       }
     }
 
   //private:
     AsyncRandomAccessReadDevice& device_;
     boost::uint64_t offset_;
     boost::asio::basic_streambuf<Allocator>& streambuf_;
     std::size_t total_transferred_;
     ReadHandler handler_;
   };
 
   template <typename AsyncRandomAccessReadDevice, typename Allocator,
       typename CompletionCondition, typename ReadHandler>
   inline void* asio_handler_allocate(std::size_t size,
       read_at_streambuf_op<AsyncRandomAccessReadDevice, Allocator,
         CompletionCondition, ReadHandler>* this_handler)
   {
     return boost_asio_handler_alloc_helpers::allocate(
         size, this_handler->handler_);
   }
 
   template <typename AsyncRandomAccessReadDevice, typename Allocator,
       typename CompletionCondition, typename ReadHandler>
   inline void asio_handler_deallocate(void* pointer, std::size_t size,
       read_at_streambuf_op<AsyncRandomAccessReadDevice, Allocator,
         CompletionCondition, ReadHandler>* this_handler)
   {
     boost_asio_handler_alloc_helpers::deallocate(
         pointer, size, 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)
-  {
-    boost_asio_handler_invoke_helpers::invoke(
-        function, this_handler->handler_);
-  }
-
-  template <typename Function, typename AsyncRandomAccessReadDevice,
-      typename Allocator, typename CompletionCondition, typename ReadHandler>
   inline void asio_handler_invoke(const Function& function,
       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,
-    CompletionCondition completion_condition,
-    BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+    CompletionCondition completion_condition, 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))(
+  detail::read_at_streambuf_op<AsyncRandomAccessReadDevice,
+    Allocator, CompletionCondition, ReadHandler>(
+      d, offset, b, completion_condition, handler)(
         boost::system::error_code(), 0, 1);
 }
 
 template <typename AsyncRandomAccessReadDevice, typename Allocator,
     typename ReadHandler>
 inline void async_read_at(AsyncRandomAccessReadDevice& d,
     boost::uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
-    BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+    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);
+  async_read_at(d, offset, b, transfer_all(), handler);
 }
 
 #endif // !defined(BOOST_NO_IOSTREAM)
 
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // BOOST_ASIO_IMPL_READ_AT_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..5eeb1bc 100644
--- a/3rdParty/Boost/src/boost/asio/impl/read_until.hpp
+++ b/3rdParty/Boost/src/boost/asio/impl/read_until.hpp
@@ -1,1086 +1,904 @@
 //
 // impl/read_until.hpp
 // ~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_IMPL_READ_UNTIL_HPP
 #define BOOST_ASIO_IMPL_READ_UNTIL_HPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #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_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 SyncReadStream, typename Allocator>
 inline std::size_t read_until(SyncReadStream& s,
     boost::asio::basic_streambuf<Allocator>& b, char delim)
 {
   boost::system::error_code ec;
   std::size_t bytes_transferred = read_until(s, b, delim, ec);
-  boost::asio::detail::throw_error(ec, "read_until");
+  boost::asio::detail::throw_error(ec);
   return bytes_transferred;
 }
 
 template <typename SyncReadStream, typename Allocator>
 std::size_t read_until(SyncReadStream& s,
     boost::asio::basic_streambuf<Allocator>& b, char delim,
     boost::system::error_code& ec)
 {
   std::size_t search_position = 0;
   for (;;)
   {
     // Determine the range of the data to be searched.
     typedef typename boost::asio::basic_streambuf<
       Allocator>::const_buffers_type const_buffers_type;
     typedef boost::asio::buffers_iterator<const_buffers_type> iterator;
     const_buffers_type buffers = b.data();
     iterator begin = iterator::begin(buffers);
-    iterator start_pos = begin + search_position;
+    iterator start = begin + search_position;
     iterator end = iterator::end(buffers);
 
     // Look for a match.
-    iterator iter = std::find(start_pos, end, delim);
+    iterator iter = std::find(start, end, delim);
     if (iter != end)
     {
       // Found a match. We're done.
       ec = boost::system::error_code();
       return iter - begin + 1;
     }
     else
     {
       // No match. Next search can start with the new data.
       search_position = end - begin;
     }
 
     // Check if buffer is full.
     if (b.size() == b.max_size())
     {
       ec = error::not_found;
       return 0;
     }
 
     // Need more data.
     std::size_t bytes_to_read = read_size_helper(b, 65536);
     b.commit(s.read_some(b.prepare(bytes_to_read), ec));
     if (ec)
       return 0;
   }
 }
 
 template <typename SyncReadStream, typename Allocator>
 inline std::size_t read_until(SyncReadStream& s,
     boost::asio::basic_streambuf<Allocator>& b, const std::string& delim)
 {
   boost::system::error_code ec;
   std::size_t bytes_transferred = read_until(s, b, delim, ec);
-  boost::asio::detail::throw_error(ec, "read_until");
+  boost::asio::detail::throw_error(ec);
   return bytes_transferred;
 }
 
 namespace detail
 {
   // Algorithm that finds a subsequence of equal values in a sequence. Returns
   // (iterator,true) if a full match was found, in which case the iterator
   // points to the beginning of the match. Returns (iterator,false) if a
   // partial match was found at the end of the first sequence, in which case
   // the iterator points to the beginning of the partial match. Returns
   // (last1,false) if no full or partial match was found.
   template <typename Iterator1, typename Iterator2>
   std::pair<Iterator1, bool> partial_search(
       Iterator1 first1, Iterator1 last1, Iterator2 first2, Iterator2 last2)
   {
     for (Iterator1 iter1 = first1; iter1 != last1; ++iter1)
     {
       Iterator1 test_iter1 = iter1;
       Iterator2 test_iter2 = first2;
       for (;; ++test_iter1, ++test_iter2)
       {
         if (test_iter2 == last2)
           return std::make_pair(iter1, true);
         if (test_iter1 == last1)
         {
           if (test_iter2 != first2)
             return std::make_pair(iter1, false);
           else
             break;
         }
         if (*test_iter1 != *test_iter2)
           break;
       }
     }
     return std::make_pair(last1, false);
   }
 } // namespace detail
 
 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)
 {
   std::size_t search_position = 0;
   for (;;)
   {
     // Determine the range of the data to be searched.
     typedef typename boost::asio::basic_streambuf<
       Allocator>::const_buffers_type const_buffers_type;
     typedef boost::asio::buffers_iterator<const_buffers_type> iterator;
     const_buffers_type buffers = b.data();
     iterator begin = iterator::begin(buffers);
-    iterator start_pos = begin + search_position;
+    iterator start = begin + search_position;
     iterator end = iterator::end(buffers);
 
     // Look for a match.
     std::pair<iterator, bool> result = detail::partial_search(
-        start_pos, end, delim.begin(), delim.end());
+        start, end, delim.begin(), delim.end());
     if (result.first != end)
     {
       if (result.second)
       {
         // Full match. We're done.
         ec = boost::system::error_code();
         return result.first - begin + delim.length();
       }
       else
       {
         // Partial match. Next search needs to start from beginning of match.
         search_position = result.first - begin;
       }
     }
     else
     {
       // No match. Next search can start with the new data.
       search_position = end - begin;
     }
 
     // Check if buffer is full.
     if (b.size() == b.max_size())
     {
       ec = error::not_found;
       return 0;
     }
 
     // Need more data.
     std::size_t bytes_to_read = read_size_helper(b, 65536);
     b.commit(s.read_some(b.prepare(bytes_to_read), ec));
     if (ec)
       return 0;
   }
 }
 
 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);
-  boost::asio::detail::throw_error(ec, "read_until");
+  boost::asio::detail::throw_error(ec);
   return bytes_transferred;
 }
 
 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)
 {
   std::size_t search_position = 0;
   for (;;)
   {
     // Determine the range of the data to be searched.
     typedef typename boost::asio::basic_streambuf<
       Allocator>::const_buffers_type const_buffers_type;
     typedef boost::asio::buffers_iterator<const_buffers_type> iterator;
     const_buffers_type buffers = b.data();
     iterator begin = iterator::begin(buffers);
-    iterator start_pos = begin + search_position;
+    iterator start = begin + search_position;
     iterator end = iterator::end(buffers);
 
     // Look for a match.
     boost::match_results<iterator,
       typename std::vector<boost::sub_match<iterator> >::allocator_type>
         match_results;
-    if (regex_search(start_pos, end, match_results, expr,
+    if (regex_search(start, end, match_results, expr,
           boost::match_default | boost::match_partial))
     {
       if (match_results[0].matched)
       {
         // Full match. We're done.
         ec = boost::system::error_code();
         return match_results[0].second - begin;
       }
       else
       {
         // Partial match. Next search needs to start from beginning of match.
         search_position = match_results[0].first - begin;
       }
     }
     else
     {
       // No match. Next search can start with the new data.
       search_position = end - begin;
     }
 
     // Check if buffer is full.
     if (b.size() == b.max_size())
     {
       ec = error::not_found;
       return 0;
     }
 
     // Need more data.
     std::size_t bytes_to_read = read_size_helper(b, 65536);
     b.commit(s.read_some(b.prepare(bytes_to_read), ec));
     if (ec)
       return 0;
   }
 }
 
 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*)
 {
   std::size_t search_position = 0;
   for (;;)
   {
     // Determine the range of the data to be searched.
     typedef typename boost::asio::basic_streambuf<
       Allocator>::const_buffers_type const_buffers_type;
     typedef boost::asio::buffers_iterator<const_buffers_type> iterator;
     const_buffers_type buffers = b.data();
     iterator begin = iterator::begin(buffers);
-    iterator start_pos = begin + search_position;
+    iterator start = begin + search_position;
     iterator end = iterator::end(buffers);
 
     // Look for a match.
-    std::pair<iterator, bool> result = match_condition(start_pos, end);
+    std::pair<iterator, bool> result = match_condition(start, end);
     if (result.second)
     {
       // Full match. We're done.
       ec = boost::system::error_code();
       return result.first - begin;
     }
     else if (result.first != end)
     {
       // Partial match. Next search needs to start from beginning of match.
       search_position = result.first - begin;
     }
     else
     {
       // No match. Next search can start with the new data.
       search_position = end - begin;
     }
 
     // Check if buffer is full.
     if (b.size() == b.max_size())
     {
       ec = error::not_found;
       return 0;
     }
 
     // Need more data.
     std::size_t bytes_to_read = read_size_helper(b, 65536);
     b.commit(s.read_some(b.prepare(bytes_to_read), ec));
     if (ec)
       return 0;
   }
 }
 
 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*)
 {
   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");
+  boost::asio::detail::throw_error(ec);
   return bytes_transferred;
 }
 
 namespace detail
 {
   template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
   class read_until_delim_op
   {
   public:
     read_until_delim_op(AsyncReadStream& stream,
         boost::asio::basic_streambuf<Allocator>& streambuf,
-        char delim, ReadHandler& handler)
+        char delim, ReadHandler handler)
       : stream_(stream),
         streambuf_(streambuf),
         delim_(delim),
         search_position_(0),
-        handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))
+        handler_(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_),
-        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_),
-        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)
       {
       case 1:
         for (;;)
         {
           {
             // Determine the range of the data to be searched.
             typedef typename boost::asio::basic_streambuf<
               Allocator>::const_buffers_type const_buffers_type;
             typedef boost::asio::buffers_iterator<const_buffers_type> iterator;
             const_buffers_type buffers = streambuf_.data();
             iterator begin = iterator::begin(buffers);
-            iterator start_pos = begin + search_position_;
+            iterator start = begin + search_position_;
             iterator end = iterator::end(buffers);
 
             // Look for a match.
-            iterator iter = std::find(start_pos, end, delim_);
+            iterator iter = std::find(start, end, delim_);
             if (iter != end)
             {
               // Found a match. We're done.
               search_position_ = iter - begin + 1;
               bytes_to_read = 0;
             }
 
             // No match yet. Check if buffer is full.
             else if (streambuf_.size() == streambuf_.max_size())
             {
               search_position_ = not_found;
               bytes_to_read = 0;
             }
 
             // Need to read some more data.
             else
             {
               // Next search can start with the new data.
               search_position_ = end - begin;
               bytes_to_read = read_size_helper(streambuf_, 65536);
             }
           }
 
           // Check if we're done.
           if (!start && bytes_to_read == 0)
             break;
 
           // Start a new asynchronous read operation to obtain more data.
-          stream_.async_read_some(streambuf_.prepare(bytes_to_read),
-              BOOST_ASIO_MOVE_CAST(read_until_delim_op)(*this));
+          stream_.async_read_some(streambuf_.prepare(bytes_to_read), *this);
           return; default:
           streambuf_.commit(bytes_transferred);
           if (ec || bytes_transferred == 0)
             break;
         }
 
         const boost::system::error_code result_ec =
           (search_position_ == not_found)
           ? error::not_found : ec;
 
         const std::size_t result_n =
           (ec || search_position_ == not_found)
           ? 0 : search_position_;
 
         handler_(result_ec, result_n);
       }
     }
 
   //private:
     AsyncReadStream& stream_;
     boost::asio::basic_streambuf<Allocator>& streambuf_;
     char delim_;
     std::size_t search_position_;
     ReadHandler handler_;
   };
 
   template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
   inline void* asio_handler_allocate(std::size_t size,
       read_until_delim_op<AsyncReadStream,
         Allocator, ReadHandler>* this_handler)
   {
     return boost_asio_handler_alloc_helpers::allocate(
         size, this_handler->handler_);
   }
 
   template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
   inline void asio_handler_deallocate(void* pointer, std::size_t size,
       read_until_delim_op<AsyncReadStream,
         Allocator, ReadHandler>* this_handler)
   {
     boost_asio_handler_alloc_helpers::deallocate(
         pointer, size, 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)
-  {
-    boost_asio_handler_invoke_helpers::invoke(
-        function, this_handler->handler_);
-  }
-
-  template <typename Function, typename AsyncReadStream, typename Allocator,
-      typename ReadHandler>
   inline void asio_handler_invoke(const Function& function,
       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::basic_streambuf<Allocator>& b, char delim,
-    BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+    boost::asio::basic_streambuf<Allocator>& b, char delim, 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::read_until_delim_op<
+    AsyncReadStream, Allocator, ReadHandler>(
+      s, b, delim, handler)(
+        boost::system::error_code(), 0, 1);
 }
 
 namespace detail
 {
   template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
   class read_until_delim_string_op
   {
   public:
     read_until_delim_string_op(AsyncReadStream& stream,
         boost::asio::basic_streambuf<Allocator>& streambuf,
-        const std::string& delim, ReadHandler& handler)
+        const std::string& delim, ReadHandler handler)
       : stream_(stream),
         streambuf_(streambuf),
         delim_(delim),
         search_position_(0),
-        handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))
+        handler_(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_),
-        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_)),
-        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)
       {
       case 1:
         for (;;)
         {
           {
             // Determine the range of the data to be searched.
             typedef typename boost::asio::basic_streambuf<
               Allocator>::const_buffers_type const_buffers_type;
             typedef boost::asio::buffers_iterator<const_buffers_type> iterator;
             const_buffers_type buffers = streambuf_.data();
             iterator begin = iterator::begin(buffers);
-            iterator start_pos = begin + search_position_;
+            iterator start = begin + search_position_;
             iterator end = iterator::end(buffers);
 
             // Look for a match.
             std::pair<iterator, bool> result = detail::partial_search(
-                start_pos, end, delim_.begin(), delim_.end());
+                start, end, delim_.begin(), delim_.end());
             if (result.first != end && result.second)
             {
               // Full match. We're done.
               search_position_ = result.first - begin + delim_.length();
               bytes_to_read = 0;
             }
 
             // No match yet. Check if buffer is full.
             else if (streambuf_.size() == streambuf_.max_size())
             {
               search_position_ = not_found;
               bytes_to_read = 0;
             }
 
             // Need to read some more data.
             else
             {
               if (result.first != end)
               {
                 // Partial match. Next search needs to start from beginning of
                 // match.
                 search_position_ = result.first - begin;
               }
               else
               {
                 // Next search can start with the new data.
                 search_position_ = end - begin;
               }
 
               bytes_to_read = read_size_helper(streambuf_, 65536);
             }
           }
 
           // Check if we're done.
           if (!start && bytes_to_read == 0)
             break;
 
           // Start a new asynchronous read operation to obtain more data.
-          stream_.async_read_some(streambuf_.prepare(bytes_to_read),
-              BOOST_ASIO_MOVE_CAST(read_until_delim_string_op)(*this));
+          stream_.async_read_some(streambuf_.prepare(bytes_to_read), *this);
           return; default:
           streambuf_.commit(bytes_transferred);
           if (ec || bytes_transferred == 0)
             break;
         }
 
         const boost::system::error_code result_ec =
           (search_position_ == not_found)
           ? error::not_found : ec;
 
         const std::size_t result_n =
           (ec || search_position_ == not_found)
           ? 0 : search_position_;
 
         handler_(result_ec, result_n);
       }
     }
 
   //private:
     AsyncReadStream& stream_;
     boost::asio::basic_streambuf<Allocator>& streambuf_;
     std::string delim_;
     std::size_t search_position_;
     ReadHandler handler_;
   };
 
   template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
   inline void* asio_handler_allocate(std::size_t size,
       read_until_delim_string_op<AsyncReadStream,
         Allocator, ReadHandler>* this_handler)
   {
     return boost_asio_handler_alloc_helpers::allocate(
         size, this_handler->handler_);
   }
 
   template <typename AsyncReadStream, typename Allocator, typename ReadHandler>
   inline void asio_handler_deallocate(void* pointer, std::size_t size,
       read_until_delim_string_op<AsyncReadStream,
         Allocator, ReadHandler>* this_handler)
   {
     boost_asio_handler_alloc_helpers::deallocate(
         pointer, size, 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)
-  {
-    boost_asio_handler_invoke_helpers::invoke(
-        function, this_handler->handler_);
-  }
-
-  template <typename Function, typename AsyncReadStream,
-      typename Allocator, typename ReadHandler>
   inline void asio_handler_invoke(const Function& function,
       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::basic_streambuf<Allocator>& b, const std::string& delim,
-    BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+    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::read_until_delim_string_op<
+    AsyncReadStream, Allocator, ReadHandler>(
+      s, b, delim, handler)(
+        boost::system::error_code(), 0, 1);
 }
 
 namespace detail
 {
   template <typename AsyncReadStream, typename Allocator,
       typename RegEx, typename ReadHandler>
   class read_until_expr_op
   {
   public:
     read_until_expr_op(AsyncReadStream& stream,
         boost::asio::basic_streambuf<Allocator>& streambuf,
-        const boost::regex& expr, ReadHandler& handler)
+        const boost::regex& expr, ReadHandler handler)
       : stream_(stream),
         streambuf_(streambuf),
         expr_(expr),
         search_position_(0),
-        handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))
+        handler_(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_),
-        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_),
-        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)
       {
       case 1:
         for (;;)
         {
           {
             // Determine the range of the data to be searched.
             typedef typename boost::asio::basic_streambuf<
               Allocator>::const_buffers_type const_buffers_type;
             typedef boost::asio::buffers_iterator<const_buffers_type> iterator;
             const_buffers_type buffers = streambuf_.data();
             iterator begin = iterator::begin(buffers);
-            iterator start_pos = begin + search_position_;
+            iterator start = begin + search_position_;
             iterator end = iterator::end(buffers);
 
             // Look for a match.
             boost::match_results<iterator,
               typename std::vector<boost::sub_match<iterator> >::allocator_type>
                 match_results;
-            bool match = regex_search(start_pos, end, match_results, expr_,
+            bool match = regex_search(start, end, match_results, expr_,
                 boost::match_default | boost::match_partial);
             if (match && match_results[0].matched)
             {
               // Full match. We're done.
               search_position_ = match_results[0].second - begin;
               bytes_to_read = 0;
             }
 
             // No match yet. Check if buffer is full.
             else if (streambuf_.size() == streambuf_.max_size())
             {
               search_position_ = not_found;
               bytes_to_read = 0;
             }
 
             // Need to read some more data.
             else
             {
               if (match)
               {
                 // Partial match. Next search needs to start from beginning of
                 // match.
                 search_position_ = match_results[0].first - begin;
               }
               else
               {
                 // Next search can start with the new data.
                 search_position_ = end - begin;
               }
 
               bytes_to_read = read_size_helper(streambuf_, 65536);
             }
           }
 
           // Check if we're done.
           if (!start && bytes_to_read == 0)
             break;
 
           // Start a new asynchronous read operation to obtain more data.
-          stream_.async_read_some(streambuf_.prepare(bytes_to_read),
-              BOOST_ASIO_MOVE_CAST(read_until_expr_op)(*this));
+          stream_.async_read_some(streambuf_.prepare(bytes_to_read), *this);
           return; default:
           streambuf_.commit(bytes_transferred);
           if (ec || bytes_transferred == 0)
             break;
         }
 
         const boost::system::error_code result_ec =
           (search_position_ == not_found)
           ? error::not_found : ec;
 
         const std::size_t result_n =
           (ec || search_position_ == not_found)
           ? 0 : search_position_;
 
         handler_(result_ec, result_n);
       }
     }
 
   //private:
     AsyncReadStream& stream_;
     boost::asio::basic_streambuf<Allocator>& streambuf_;
     RegEx expr_;
     std::size_t search_position_;
     ReadHandler handler_;
   };
 
   template <typename AsyncReadStream, typename Allocator,
       typename RegEx, typename ReadHandler>
   inline void* asio_handler_allocate(std::size_t size,
       read_until_expr_op<AsyncReadStream,
         Allocator, RegEx, ReadHandler>* this_handler)
   {
     return boost_asio_handler_alloc_helpers::allocate(
         size, this_handler->handler_);
   }
 
   template <typename AsyncReadStream, typename Allocator,
       typename RegEx, typename ReadHandler>
   inline void asio_handler_deallocate(void* pointer, std::size_t size,
       read_until_expr_op<AsyncReadStream,
         Allocator, RegEx, ReadHandler>* this_handler)
   {
     boost_asio_handler_alloc_helpers::deallocate(
         pointer, size, 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)
-  {
-    boost_asio_handler_invoke_helpers::invoke(
-        function, this_handler->handler_);
-  }
-
-  template <typename Function, typename AsyncReadStream, typename Allocator,
-      typename RegEx, typename ReadHandler>
   inline void asio_handler_invoke(const Function& function,
       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::basic_streambuf<Allocator>& b, const boost::regex& expr,
-    BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+    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::read_until_expr_op<AsyncReadStream,
+    Allocator, boost::regex, ReadHandler>(
+      s, b, expr, handler)(
+        boost::system::error_code(), 0, 1);
 }
 
 namespace detail
 {
   template <typename AsyncReadStream, typename Allocator,
       typename MatchCondition, typename ReadHandler>
   class read_until_match_op
   {
   public:
     read_until_match_op(AsyncReadStream& stream,
         boost::asio::basic_streambuf<Allocator>& streambuf,
-        MatchCondition match_condition, ReadHandler& handler)
+        MatchCondition match_condition, ReadHandler handler)
       : stream_(stream),
         streambuf_(streambuf),
         match_condition_(match_condition),
         search_position_(0),
-        handler_(BOOST_ASIO_MOVE_CAST(ReadHandler)(handler))
+        handler_(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_),
-        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_),
-        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)
       {
       case 1:
         for (;;)
         {
           {
             // Determine the range of the data to be searched.
             typedef typename boost::asio::basic_streambuf<
               Allocator>::const_buffers_type const_buffers_type;
             typedef boost::asio::buffers_iterator<const_buffers_type> iterator;
             const_buffers_type buffers = streambuf_.data();
             iterator begin = iterator::begin(buffers);
-            iterator start_pos = begin + search_position_;
+            iterator start = begin + search_position_;
             iterator end = iterator::end(buffers);
 
             // Look for a match.
-            std::pair<iterator, bool> result = match_condition_(start_pos, end);
+            std::pair<iterator, bool> result = match_condition_(start, end);
             if (result.second)
             {
               // Full match. We're done.
               search_position_ = result.first - begin;
               bytes_to_read = 0;
             }
 
             // No match yet. Check if buffer is full.
             else if (streambuf_.size() == streambuf_.max_size())
             {
               search_position_ = not_found;
               bytes_to_read = 0;
             }
 
             // Need to read some more data.
             else
             {
               if (result.first != end)
               {
                 // Partial match. Next search needs to start from beginning of
                 // match.
                 search_position_ = result.first - begin;
               }
               else
               {
                 // Next search can start with the new data.
                 search_position_ = end - begin;
               }
 
               bytes_to_read = read_size_helper(streambuf_, 65536);
             }
           }
 
           // Check if we're done.
           if (!start && bytes_to_read == 0)
             break;
 
           // Start a new asynchronous read operation to obtain more data.
-          stream_.async_read_some(streambuf_.prepare(bytes_to_read),
-              BOOST_ASIO_MOVE_CAST(read_until_match_op)(*this));
+          stream_.async_read_some(streambuf_.prepare(bytes_to_read), *this);
           return; default:
           streambuf_.commit(bytes_transferred);
           if (ec || bytes_transferred == 0)
             break;
         }
 
         const boost::system::error_code result_ec =
           (search_position_ == not_found)
           ? error::not_found : ec;
 
         const std::size_t result_n =
           (ec || search_position_ == not_found)
           ? 0 : search_position_;
 
         handler_(result_ec, result_n);
       }
     }
 
   //private:
     AsyncReadStream& stream_;
     boost::asio::basic_streambuf<Allocator>& streambuf_;
     MatchCondition match_condition_;
     std::size_t search_position_;
     ReadHandler handler_;
   };
 
   template <typename AsyncReadStream, typename Allocator,
       typename MatchCondition, typename ReadHandler>
   inline void* asio_handler_allocate(std::size_t size,
       read_until_match_op<AsyncReadStream,
         Allocator, MatchCondition, ReadHandler>* this_handler)
   {
     return boost_asio_handler_alloc_helpers::allocate(
         size, this_handler->handler_);
   }
 
   template <typename AsyncReadStream, typename Allocator,
       typename MatchCondition, typename ReadHandler>
   inline void asio_handler_deallocate(void* pointer, std::size_t size,
       read_until_match_op<AsyncReadStream,
         Allocator, MatchCondition, ReadHandler>* this_handler)
   {
     boost_asio_handler_alloc_helpers::deallocate(
         pointer, size, 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)
-  {
-    boost_asio_handler_invoke_helpers::invoke(
-        function, this_handler->handler_);
-  }
-
-  template <typename Function, typename AsyncReadStream, typename Allocator,
-      typename MatchCondition, typename ReadHandler>
   inline void asio_handler_invoke(const Function& function,
       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::basic_streambuf<Allocator>& b,
-    MatchCondition match_condition, BOOST_ASIO_MOVE_ARG(ReadHandler) handler,
+    MatchCondition match_condition, ReadHandler handler,
     typename boost::enable_if<is_match_condition<MatchCondition> >::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::read_until_match_op<
+    AsyncReadStream, Allocator, MatchCondition, ReadHandler>(
+      s, b, match_condition, handler)(
+        boost::system::error_code(), 0, 1);
 }
 
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // BOOST_ASIO_IMPL_READ_UNTIL_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..c75f8c2 100644
--- a/3rdParty/Boost/src/boost/asio/impl/serial_port_base.hpp
+++ b/3rdParty/Boost/src/boost/asio/impl/serial_port_base.hpp
@@ -1,40 +1,40 @@
 //
 // impl/serial_port_base.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2011 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)
 //
 
 #ifndef BOOST_ASIO_IMPL_SERIAL_PORT_BASE_HPP
 #define BOOST_ASIO_IMPL_SERIAL_PORT_BASE_HPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 
 inline serial_port_base::baud_rate::baud_rate(unsigned int rate)
   : value_(rate)
 {
 }
 
 inline unsigned int serial_port_base::baud_rate::value() const
 {
   return value_;
 }
 
 inline serial_port_base::flow_control::type
 serial_port_base::flow_control::value() const
 {
   return value_;
 }
 
 inline serial_port_base::parity::type serial_port_base::parity::value() const
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..c665ac8 100644
--- a/3rdParty/Boost/src/boost/asio/impl/serial_port_base.ipp
+++ b/3rdParty/Boost/src/boost/asio/impl/serial_port_base.ipp
@@ -1,40 +1,40 @@
 //
 // impl/serial_port_base.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2011 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)
 //
 
 #ifndef BOOST_ASIO_IMPL_SERIAL_PORT_BASE_IPP
 #define BOOST_ASIO_IMPL_SERIAL_PORT_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_HAS_SERIAL_PORT)
 
 #include <stdexcept>
 #include <boost/throw_exception.hpp>
 #include <boost/asio/error.hpp>
 #include <boost/asio/serial_port_base.hpp>
 
 #if defined(GENERATING_DOCUMENTATION)
 # define BOOST_ASIO_OPTION_STORAGE implementation_defined
 #elif defined(BOOST_WINDOWS) || defined(__CYGWIN__)
 # define BOOST_ASIO_OPTION_STORAGE DCB
 #else
 # define BOOST_ASIO_OPTION_STORAGE termios
 #endif
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 
diff --git a/3rdParty/Boost/src/boost/asio/impl/write.hpp b/3rdParty/Boost/src/boost/asio/impl/write.hpp
index 61422e4..ae420bc 100644
--- a/3rdParty/Boost/src/boost/asio/impl/write.hpp
+++ b/3rdParty/Boost/src/boost/asio/impl/write.hpp
@@ -1,709 +1,398 @@
 //
 // impl/write.hpp
 // ~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_IMPL_WRITE_HPP
 #define BOOST_ASIO_IMPL_WRITE_HPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/buffer.hpp>
 #include <boost/asio/completion_condition.hpp>
-#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_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 SyncWriteStream, typename ConstBufferSequence,
     typename CompletionCondition>
 std::size_t write(SyncWriteStream& s, 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;
   tmp.prepare(detail::adapt_completion_condition_result(
         completion_condition(ec, total_transferred)));
   while (tmp.begin() != tmp.end())
   {
     std::size_t bytes_transferred = s.write_some(tmp, ec);
     tmp.consume(bytes_transferred);
     total_transferred += bytes_transferred;
     tmp.prepare(detail::adapt_completion_condition_result(
           completion_condition(ec, total_transferred)));
   }
   return total_transferred;
 }
 
 template <typename SyncWriteStream, typename ConstBufferSequence>
 inline std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers)
 {
   boost::system::error_code ec;
   std::size_t bytes_transferred = write(s, buffers, transfer_all(), ec);
-  boost::asio::detail::throw_error(ec, "write");
+  boost::asio::detail::throw_error(ec);
   return bytes_transferred;
 }
 
-template <typename SyncWriteStream, typename ConstBufferSequence>
-inline std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
-    boost::system::error_code& ec)
-{
-  return write(s, buffers, transfer_all(), ec);
-}
-
 template <typename SyncWriteStream, typename ConstBufferSequence,
     typename CompletionCondition>
 inline std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
     CompletionCondition completion_condition)
 {
   boost::system::error_code ec;
   std::size_t bytes_transferred = write(s, buffers, completion_condition, ec);
-  boost::asio::detail::throw_error(ec, "write");
+  boost::asio::detail::throw_error(ec);
   return bytes_transferred;
 }
 
 #if !defined(BOOST_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)
 {
   std::size_t bytes_transferred = write(s, b.data(), completion_condition, ec);
   b.consume(bytes_transferred);
   return bytes_transferred;
 }
 
 template <typename SyncWriteStream, typename Allocator>
 inline std::size_t write(SyncWriteStream& s,
     boost::asio::basic_streambuf<Allocator>& b)
 {
   boost::system::error_code ec;
   std::size_t bytes_transferred = write(s, b, transfer_all(), ec);
-  boost::asio::detail::throw_error(ec, "write");
+  boost::asio::detail::throw_error(ec);
   return bytes_transferred;
 }
 
-template <typename SyncWriteStream, typename Allocator>
-inline std::size_t write(SyncWriteStream& s,
-    boost::asio::basic_streambuf<Allocator>& b,
-    boost::system::error_code& ec)
-{
-  return write(s, b, transfer_all(), ec);
-}
-
 template <typename SyncWriteStream, typename Allocator,
     typename CompletionCondition>
 inline std::size_t write(SyncWriteStream& s,
     boost::asio::basic_streambuf<Allocator>& b,
     CompletionCondition completion_condition)
 {
   boost::system::error_code ec;
   std::size_t bytes_transferred = write(s, b, completion_condition, ec);
-  boost::asio::detail::throw_error(ec, "write");
+  boost::asio::detail::throw_error(ec);
   return bytes_transferred;
 }
 
 #endif // !defined(BOOST_NO_IOSTREAM)
 
 namespace detail
 {
   template <typename AsyncWriteStream, typename ConstBufferSequence,
       typename CompletionCondition, typename WriteHandler>
   class write_op
     : detail::base_from_completion_cond<CompletionCondition>
   {
   public:
     write_op(AsyncWriteStream& stream, const ConstBufferSequence& buffers,
-        CompletionCondition completion_condition, WriteHandler& handler)
+        CompletionCondition completion_condition, WriteHandler handler)
       : detail::base_from_completion_cond<
           CompletionCondition>(completion_condition),
         stream_(stream),
         buffers_(buffers),
         total_transferred_(0),
-        handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(handler))
+        handler_(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_),
-        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_),
-        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)
       {
         case 1:
         buffers_.prepare(this->check_for_completion(ec, total_transferred_));
         for (;;)
         {
-          stream_.async_write_some(buffers_,
-              BOOST_ASIO_MOVE_CAST(write_op)(*this));
+          stream_.async_write_some(buffers_, *this);
           return; default:
           total_transferred_ += bytes_transferred;
           buffers_.consume(bytes_transferred);
           buffers_.prepare(this->check_for_completion(ec, total_transferred_));
           if ((!ec && bytes_transferred == 0)
               || buffers_.begin() == buffers_.end())
             break;
         }
 
         handler_(ec, static_cast<const std::size_t&>(total_transferred_));
       }
     }
 
   //private:
     AsyncWriteStream& stream_;
     boost::asio::detail::consuming_buffers<
       const_buffer, ConstBufferSequence> buffers_;
     std::size_t total_transferred_;
     WriteHandler handler_;
   };
 
   template <typename AsyncWriteStream,
       typename CompletionCondition, typename WriteHandler>
   class write_op<AsyncWriteStream, boost::asio::mutable_buffers_1,
       CompletionCondition, WriteHandler>
     : detail::base_from_completion_cond<CompletionCondition>
   {
   public:
     write_op(AsyncWriteStream& stream,
         const boost::asio::mutable_buffers_1& buffers,
         CompletionCondition completion_condition,
-        WriteHandler& handler)
+        WriteHandler handler)
       : detail::base_from_completion_cond<
           CompletionCondition>(completion_condition),
         stream_(stream),
         buffer_(buffers),
         total_transferred_(0),
-        handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(handler))
+        handler_(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_),
-        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_),
-        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)
       {
         case 1:
         n = this->check_for_completion(ec, total_transferred_);
         for (;;)
         {
-          stream_.async_write_some(
-              boost::asio::buffer(buffer_ + total_transferred_, n),
-              BOOST_ASIO_MOVE_CAST(write_op)(*this));
+          stream_.async_write_some(boost::asio::buffer(
+                buffer_ + total_transferred_, n), *this);
           return; default:
           total_transferred_ += bytes_transferred;
           if ((!ec && bytes_transferred == 0)
               || (n = this->check_for_completion(ec, total_transferred_)) == 0
               || total_transferred_ == boost::asio::buffer_size(buffer_))
             break;
         }
 
         handler_(ec, static_cast<const std::size_t&>(total_transferred_));
       }
     }
 
   //private:
     AsyncWriteStream& stream_;
     boost::asio::mutable_buffer buffer_;
     std::size_t total_transferred_;
     WriteHandler handler_;
   };
 
   template <typename AsyncWriteStream,
       typename CompletionCondition, typename WriteHandler>
   class write_op<AsyncWriteStream, boost::asio::const_buffers_1,
       CompletionCondition, WriteHandler>
     : detail::base_from_completion_cond<CompletionCondition>
   {
   public:
     write_op(AsyncWriteStream& stream,
         const boost::asio::const_buffers_1& buffers,
         CompletionCondition completion_condition,
-        WriteHandler& handler)
+        WriteHandler handler)
       : detail::base_from_completion_cond<
           CompletionCondition>(completion_condition),
         stream_(stream),
         buffer_(buffers),
         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_),
-        total_transferred_(other.total_transferred_),
-        handler_(other.handler_)
+        handler_(handler)
     {
     }
 
-    write_op(write_op&& other)
-      : detail::base_from_completion_cond<CompletionCondition>(other),
-        stream_(other.stream_),
-        buffer_(other.buffer_),
-        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)
       {
         case 1:
         n = this->check_for_completion(ec, total_transferred_);
         for (;;)
         {
-          stream_.async_write_some(
-              boost::asio::buffer(buffer_ + total_transferred_, n),
-              BOOST_ASIO_MOVE_CAST(write_op)(*this));
+          stream_.async_write_some(boost::asio::buffer(
+                buffer_ + total_transferred_, n), *this);
           return; default:
           total_transferred_ += bytes_transferred;
           if ((!ec && bytes_transferred == 0)
               || (n = this->check_for_completion(ec, total_transferred_)) == 0
               || total_transferred_ == boost::asio::buffer_size(buffer_))
             break;
         }
 
         handler_(ec, static_cast<const std::size_t&>(total_transferred_));
       }
     }
 
   //private:
     AsyncWriteStream& stream_;
     boost::asio::const_buffer buffer_;
     std::size_t total_transferred_;
     WriteHandler handler_;
   };
 
-  template <typename AsyncWriteStream, typename Elem,
-      typename CompletionCondition, typename WriteHandler>
-  class write_op<AsyncWriteStream, boost::array<Elem, 2>,
-      CompletionCondition, WriteHandler>
-    : detail::base_from_completion_cond<CompletionCondition>
-  {
-  public:
-    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),
-        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_),
-        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_),
-        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)
-    {
-      typename boost::asio::detail::dependent_type<Elem,
-          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)
-      {
-        case 1:
-        n = this->check_for_completion(ec, total_transferred_);
-        for (;;)
-        {
-          bufs[0] = boost::asio::buffer(bufs[0] + total_transferred_, n);
-          bufs[1] = boost::asio::buffer(
-              bufs[1] + (total_transferred_ < buffer_size0
-                ? 0 : total_transferred_ - buffer_size0),
-              n - boost::asio::buffer_size(bufs[0]));
-          stream_.async_write_some(bufs, BOOST_ASIO_MOVE_CAST(write_op)(*this));
-          return; default:
-          total_transferred_ += bytes_transferred;
-          if ((!ec && bytes_transferred == 0)
-              || (n = this->check_for_completion(ec, total_transferred_)) == 0
-              || total_transferred_ == buffer_size0 + buffer_size1)
-            break;
-        }
-
-        handler_(ec, static_cast<const std::size_t&>(total_transferred_));
-      }
-    }
-
-  //private:
-    AsyncWriteStream& stream_;
-    boost::array<Elem, 2> buffers_;
-    std::size_t total_transferred_;
-    WriteHandler handler_;
-  };
-
-#if defined(BOOST_ASIO_HAS_STD_ARRAY)
-
-  template <typename AsyncWriteStream, typename Elem,
-      typename CompletionCondition, typename WriteHandler>
-  class write_op<AsyncWriteStream, std::array<Elem, 2>,
-      CompletionCondition, WriteHandler>
-    : detail::base_from_completion_cond<CompletionCondition>
-  {
-  public:
-    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),
-        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_),
-        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_),
-        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)
-    {
-      typename boost::asio::detail::dependent_type<Elem,
-          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)
-      {
-        case 1:
-        n = this->check_for_completion(ec, total_transferred_);
-        for (;;)
-        {
-          bufs[0] = boost::asio::buffer(bufs[0] + total_transferred_, n);
-          bufs[1] = boost::asio::buffer(
-              bufs[1] + (total_transferred_ < buffer_size0
-                ? 0 : total_transferred_ - buffer_size0),
-              n - boost::asio::buffer_size(bufs[0]));
-          stream_.async_write_some(bufs, BOOST_ASIO_MOVE_CAST(write_op)(*this));
-          return; default:
-          total_transferred_ += bytes_transferred;
-          if ((!ec && bytes_transferred == 0)
-              || (n = this->check_for_completion(ec, total_transferred_)) == 0
-              || total_transferred_ == buffer_size0 + buffer_size1)
-            break;
-        }
-
-        handler_(ec, static_cast<const std::size_t&>(total_transferred_));
-      }
-    }
-
-  //private:
-    AsyncWriteStream& stream_;
-    std::array<Elem, 2> buffers_;
-    std::size_t total_transferred_;
-    WriteHandler handler_;
-  };
-
-#endif // defined(BOOST_ASIO_HAS_STD_ARRAY)
-
   template <typename AsyncWriteStream, typename ConstBufferSequence,
       typename CompletionCondition, typename WriteHandler>
   inline void* asio_handler_allocate(std::size_t size,
       write_op<AsyncWriteStream, ConstBufferSequence,
         CompletionCondition, WriteHandler>* this_handler)
   {
     return boost_asio_handler_alloc_helpers::allocate(
         size, this_handler->handler_);
   }
 
   template <typename AsyncWriteStream, typename ConstBufferSequence,
       typename CompletionCondition, typename WriteHandler>
   inline void asio_handler_deallocate(void* pointer, std::size_t size,
       write_op<AsyncWriteStream, ConstBufferSequence,
         CompletionCondition, WriteHandler>* this_handler)
   {
     boost_asio_handler_alloc_helpers::deallocate(
         pointer, size, 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)
-  {
-    boost_asio_handler_invoke_helpers::invoke(
-        function, this_handler->handler_);
-  }
-
-  template <typename Function, typename AsyncWriteStream,
-      typename ConstBufferSequence, typename CompletionCondition,
-      typename WriteHandler>
   inline void asio_handler_invoke(const Function& function,
       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,
-    CompletionCondition completion_condition,
-    BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
+    CompletionCondition completion_condition, 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))(
+  detail::write_op<AsyncWriteStream, ConstBufferSequence,
+    CompletionCondition, WriteHandler>(
+      s, buffers, completion_condition, handler)(
         boost::system::error_code(), 0, 1);
 }
 
 template <typename AsyncWriteStream, typename ConstBufferSequence,
     typename WriteHandler>
 inline void async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
-    BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
+    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);
+  async_write(s, buffers, transfer_all(), handler);
 }
 
 #if !defined(BOOST_NO_IOSTREAM)
 
 namespace detail
 {
-  template <typename Allocator, typename WriteHandler>
+  template <typename AsyncWriteStream, typename Allocator,
+      typename WriteHandler>
   class write_streambuf_handler
   {
   public:
     write_streambuf_handler(boost::asio::basic_streambuf<Allocator>& streambuf,
-        WriteHandler& handler)
+        WriteHandler handler)
       : streambuf_(streambuf),
-        handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(handler))
+        handler_(handler)
     {
     }
 
-#if defined(BOOST_ASIO_HAS_MOVE)
-    write_streambuf_handler(const write_streambuf_handler& other)
-      : streambuf_(other.streambuf_),
-        handler_(other.handler_)
-    {
-    }
-
-    write_streambuf_handler(write_streambuf_handler&& other)
-      : streambuf_(other.streambuf_),
-        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_transferred)
     {
       streambuf_.consume(bytes_transferred);
       handler_(ec, bytes_transferred);
     }
 
   //private:
     boost::asio::basic_streambuf<Allocator>& streambuf_;
     WriteHandler handler_;
   };
 
-  template <typename Allocator, typename WriteHandler>
+  template <typename AsyncWriteStream, typename Allocator,
+      typename WriteHandler>
   inline void* asio_handler_allocate(std::size_t size,
-      write_streambuf_handler<Allocator, WriteHandler>* this_handler)
+      write_streambuf_handler<AsyncWriteStream,
+        Allocator, WriteHandler>* this_handler)
   {
     return boost_asio_handler_alloc_helpers::allocate(
         size, this_handler->handler_);
   }
 
-  template <typename Allocator, typename WriteHandler>
+  template <typename AsyncWriteStream, typename Allocator,
+      typename WriteHandler>
   inline void asio_handler_deallocate(void* pointer, std::size_t size,
-      write_streambuf_handler<Allocator, WriteHandler>* this_handler)
+      write_streambuf_handler<AsyncWriteStream,
+        Allocator, WriteHandler>* this_handler)
   {
     boost_asio_handler_alloc_helpers::deallocate(
         pointer, size, 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_);
-  }
-
-  template <typename Function, typename Allocator, typename WriteHandler>
+  template <typename Function, typename AsyncWriteStream, typename Allocator,
+      typename WriteHandler>
   inline void asio_handler_invoke(const Function& function,
-      write_streambuf_handler<Allocator, WriteHandler>* this_handler)
+      write_streambuf_handler<AsyncWriteStream,
+        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,
     boost::asio::basic_streambuf<Allocator>& b,
-    CompletionCondition completion_condition,
-    BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
+    CompletionCondition completion_condition, 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;
-
   async_write(s, b.data(), completion_condition,
-      detail::make_write_streambuf_handler(
-        b, BOOST_ASIO_MOVE_CAST(WriteHandler)(handler)));
+      detail::write_streambuf_handler<
+        AsyncWriteStream, Allocator, WriteHandler>(b, handler));
 }
 
 template <typename AsyncWriteStream, typename Allocator, typename WriteHandler>
 inline void async_write(AsyncWriteStream& s,
-    boost::asio::basic_streambuf<Allocator>& b,
-    BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
+    boost::asio::basic_streambuf<Allocator>& b, 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;
-
-  async_write(s, b.data(), transfer_all(),
-      detail::make_write_streambuf_handler(
-        b, BOOST_ASIO_MOVE_CAST(WriteHandler)(handler)));
+  async_write(s, b, transfer_all(), handler);
 }
 
 #endif // !defined(BOOST_NO_IOSTREAM)
 
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // BOOST_ASIO_IMPL_WRITE_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..39dc1af 100644
--- a/3rdParty/Boost/src/boost/asio/impl/write_at.hpp
+++ b/3rdParty/Boost/src/boost/asio/impl/write_at.hpp
@@ -1,751 +1,419 @@
 //
 // impl/write_at.hpp
 // ~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_IMPL_WRITE_AT_HPP
 #define BOOST_ASIO_IMPL_WRITE_AT_HPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/buffer.hpp>
 #include <boost/asio/completion_condition.hpp>
-#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_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,
     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;
   tmp.prepare(detail::adapt_completion_condition_result(
         completion_condition(ec, total_transferred)));
   while (tmp.begin() != tmp.end())
   {
     std::size_t bytes_transferred = d.write_some_at(
         offset + total_transferred, tmp, ec);
     tmp.consume(bytes_transferred);
     total_transferred += bytes_transferred;
     tmp.prepare(detail::adapt_completion_condition_result(
           completion_condition(ec, total_transferred)));
   }
   return total_transferred;
 }
 
 template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence>
 inline std::size_t write_at(SyncRandomAccessWriteDevice& d,
     boost::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");
+  boost::asio::detail::throw_error(ec);
   return bytes_transferred;
 }
 
-template <typename SyncRandomAccessWriteDevice, typename ConstBufferSequence>
-inline std::size_t write_at(SyncRandomAccessWriteDevice& d,
-    boost::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,
     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");
+  boost::asio::detail::throw_error(ec);
   return bytes_transferred;
 }
 
 #if !defined(BOOST_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,
     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)
 {
   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");
+  boost::asio::detail::throw_error(ec);
   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,
-    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,
     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");
+  boost::asio::detail::throw_error(ec);
   return bytes_transferred;
 }
 
 #endif // !defined(BOOST_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,
-        CompletionCondition completion_condition, WriteHandler& handler)
+        CompletionCondition completion_condition, WriteHandler handler)
       : detail::base_from_completion_cond<
           CompletionCondition>(completion_condition),
         device_(device),
         offset_(offset),
         buffers_(buffers),
         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_),
-        total_transferred_(other.total_transferred_),
-        handler_(other.handler_)
+        handler_(handler)
     {
     }
 
-    write_at_op(write_at_op&& other)
-      : detail::base_from_completion_cond<CompletionCondition>(other),
-        device_(other.device_),
-        offset_(other.offset_),
-        buffers_(other.buffers_),
-        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)
       {
         case 1:
         buffers_.prepare(this->check_for_completion(ec, total_transferred_));
         for (;;)
         {
           device_.async_write_some_at(
-              offset_ + total_transferred_, buffers_,
-              BOOST_ASIO_MOVE_CAST(write_at_op)(*this));
+              offset_ + total_transferred_, buffers_, *this);
           return; default:
           total_transferred_ += bytes_transferred;
           buffers_.consume(bytes_transferred);
           buffers_.prepare(this->check_for_completion(ec, total_transferred_));
           if ((!ec && bytes_transferred == 0)
               || buffers_.begin() == buffers_.end())
             break;
         }
 
         handler_(ec, static_cast<const std::size_t&>(total_transferred_));
       }
     }
 
   //private:
     AsyncRandomAccessWriteDevice& device_;
     boost::uint64_t offset_;
     boost::asio::detail::consuming_buffers<
       const_buffer, ConstBufferSequence> buffers_;
     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,
         CompletionCondition completion_condition,
-        WriteHandler& handler)
+        WriteHandler handler)
       : detail::base_from_completion_cond<
           CompletionCondition>(completion_condition),
         device_(device),
         offset_(offset),
         buffer_(buffers),
         total_transferred_(0),
-        handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(handler))
+        handler_(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_),
-        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_),
-        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)
       {
         case 1:
         n = this->check_for_completion(ec, total_transferred_);
         for (;;)
         {
           device_.async_write_some_at(offset_ + total_transferred_,
-              boost::asio::buffer(buffer_ + total_transferred_, n),
-              BOOST_ASIO_MOVE_CAST(write_at_op)(*this));
+              boost::asio::buffer(buffer_ + total_transferred_, n), *this);
           return; default:
           total_transferred_ += bytes_transferred;
           if ((!ec && bytes_transferred == 0)
               || (n = this->check_for_completion(ec, total_transferred_)) == 0
               || total_transferred_ == boost::asio::buffer_size(buffer_))
             break;
         }
 
         handler_(ec, static_cast<const std::size_t&>(total_transferred_));
       }
     }
 
   //private:
     AsyncRandomAccessWriteDevice& device_;
     boost::uint64_t offset_;
     boost::asio::mutable_buffer buffer_;
     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,
         CompletionCondition completion_condition,
-        WriteHandler& handler)
+        WriteHandler handler)
       : detail::base_from_completion_cond<
           CompletionCondition>(completion_condition),
         device_(device),
         offset_(offset),
         buffer_(buffers),
         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_),
-        total_transferred_(other.total_transferred_),
-        handler_(other.handler_)
+        handler_(handler)
     {
     }
 
-    write_at_op(write_at_op&& other)
-      : detail::base_from_completion_cond<CompletionCondition>(other),
-        device_(other.device_),
-        offset_(other.offset_),
-        buffer_(other.buffer_),
-        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)
       {
         case 1:
         n = this->check_for_completion(ec, total_transferred_);
         for (;;)
         {
           device_.async_write_some_at(offset_ + total_transferred_,
-              boost::asio::buffer(buffer_ + total_transferred_, n),
-              BOOST_ASIO_MOVE_CAST(write_at_op)(*this));
+              boost::asio::buffer(buffer_ + total_transferred_, n), *this);
           return; default:
           total_transferred_ += bytes_transferred;
           if ((!ec && bytes_transferred == 0)
               || (n = this->check_for_completion(ec, total_transferred_)) == 0
               || total_transferred_ == boost::asio::buffer_size(buffer_))
             break;
         }
 
         handler_(ec, static_cast<const std::size_t&>(total_transferred_));
       }
     }
 
   //private:
     AsyncRandomAccessWriteDevice& device_;
     boost::uint64_t offset_;
     boost::asio::const_buffer buffer_;
     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,
-        CompletionCondition completion_condition, WriteHandler& handler)
-      : detail::base_from_completion_cond<
-          CompletionCondition>(completion_condition),
-        device_(device),
-        offset_(offset),
-        buffers_(buffers),
-        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_),
-        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_),
-        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)
-    {
-      typename boost::asio::detail::dependent_type<Elem,
-          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)
-      {
-        case 1:
-        n = this->check_for_completion(ec, total_transferred_);
-        for (;;)
-        {
-          bufs[0] = boost::asio::buffer(bufs[0] + total_transferred_, n);
-          bufs[1] = boost::asio::buffer(
-              bufs[1] + (total_transferred_ < buffer_size0
-                ? 0 : total_transferred_ - buffer_size0),
-              n - boost::asio::buffer_size(bufs[0]));
-          device_.async_write_some_at(offset_ + total_transferred_,
-              bufs, BOOST_ASIO_MOVE_CAST(write_at_op)(*this));
-          return; default:
-          total_transferred_ += bytes_transferred;
-          if ((!ec && bytes_transferred == 0)
-              || (n = this->check_for_completion(ec, total_transferred_)) == 0
-              || total_transferred_ == buffer_size0 + buffer_size1)
-            break;
-        }
-
-        handler_(ec, static_cast<const std::size_t&>(total_transferred_));
-      }
-    }
-
-  //private:
-    AsyncRandomAccessWriteDevice& device_;
-    boost::uint64_t offset_;
-    boost::array<Elem, 2> buffers_;
-    std::size_t total_transferred_;
-    WriteHandler handler_;
-  };
-
-#if defined(BOOST_ASIO_HAS_STD_ARRAY)
-
-  template <typename AsyncRandomAccessWriteDevice, typename Elem,
-      typename CompletionCondition, typename WriteHandler>
-  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,
-        CompletionCondition completion_condition, WriteHandler& handler)
-      : detail::base_from_completion_cond<
-          CompletionCondition>(completion_condition),
-        device_(device),
-        offset_(offset),
-        buffers_(buffers),
-        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_),
-        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_),
-        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)
-    {
-      typename boost::asio::detail::dependent_type<Elem,
-          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)
-      {
-        case 1:
-        n = this->check_for_completion(ec, total_transferred_);
-        for (;;)
-        {
-          bufs[0] = boost::asio::buffer(bufs[0] + total_transferred_, n);
-          bufs[1] = boost::asio::buffer(
-              bufs[1] + (total_transferred_ < buffer_size0
-                ? 0 : total_transferred_ - buffer_size0),
-              n - boost::asio::buffer_size(bufs[0]));
-          device_.async_write_some_at(offset_ + total_transferred_,
-              bufs, BOOST_ASIO_MOVE_CAST(write_at_op)(*this));
-          return; default:
-          total_transferred_ += bytes_transferred;
-          if ((!ec && bytes_transferred == 0)
-              || (n = this->check_for_completion(ec, total_transferred_)) == 0
-              || total_transferred_ == buffer_size0 + buffer_size1)
-            break;
-        }
-
-        handler_(ec, static_cast<const std::size_t&>(total_transferred_));
-      }
-    }
-
-  //private:
-    AsyncRandomAccessWriteDevice& device_;
-    boost::uint64_t offset_;
-    std::array<Elem, 2> buffers_;
-    std::size_t total_transferred_;
-    WriteHandler handler_;
-  };
-
-#endif // defined(BOOST_ASIO_HAS_STD_ARRAY)
-
   template <typename AsyncRandomAccessWriteDevice, typename ConstBufferSequence,
       typename CompletionCondition, typename WriteHandler>
   inline void* asio_handler_allocate(std::size_t size,
       write_at_op<AsyncRandomAccessWriteDevice, ConstBufferSequence,
         CompletionCondition, WriteHandler>* this_handler)
   {
     return boost_asio_handler_alloc_helpers::allocate(
         size, this_handler->handler_);
   }
 
   template <typename AsyncRandomAccessWriteDevice, typename ConstBufferSequence,
       typename CompletionCondition, typename WriteHandler>
   inline void asio_handler_deallocate(void* pointer, std::size_t size,
       write_at_op<AsyncRandomAccessWriteDevice, ConstBufferSequence,
         CompletionCondition, WriteHandler>* this_handler)
   {
     boost_asio_handler_alloc_helpers::deallocate(
         pointer, size, 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)
-  {
-    boost_asio_handler_invoke_helpers::invoke(
-        function, this_handler->handler_);
-  }
-
-  template <typename Function, typename AsyncRandomAccessWriteDevice,
-      typename ConstBufferSequence, typename CompletionCondition,
-      typename WriteHandler>
   inline void asio_handler_invoke(const Function& function,
       write_at_op<AsyncRandomAccessWriteDevice, ConstBufferSequence,
         CompletionCondition, WriteHandler>* this_handler)
   {
     boost_asio_handler_invoke_helpers::invoke(
         function, this_handler->handler_);
   }
-
-  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,
-      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,
-    CompletionCondition completion_condition,
-    BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
+    CompletionCondition completion_condition, 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))(
+  detail::write_at_op<AsyncRandomAccessWriteDevice,
+    ConstBufferSequence, CompletionCondition, WriteHandler>(
+      d, offset, buffers, completion_condition, handler)(
         boost::system::error_code(), 0, 1);
 }
 
 template <typename AsyncRandomAccessWriteDevice, typename ConstBufferSequence,
     typename WriteHandler>
 inline void async_write_at(AsyncRandomAccessWriteDevice& d,
     boost::uint64_t offset, const ConstBufferSequence& buffers,
-    BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
+    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);
+  async_write_at(d, offset, buffers, transfer_all(), handler);
 }
 
 #if !defined(BOOST_NO_IOSTREAM)
 
 namespace detail
 {
-  template <typename Allocator, typename WriteHandler>
+  template <typename AsyncRandomAccessWriteDevice,
+      typename Allocator, typename WriteHandler>
   class write_at_streambuf_op
   {
   public:
     write_at_streambuf_op(
         boost::asio::basic_streambuf<Allocator>& streambuf,
-        WriteHandler& handler)
+        WriteHandler handler)
       : streambuf_(streambuf),
-        handler_(BOOST_ASIO_MOVE_CAST(WriteHandler)(handler))
-    {
-    }
-
-#if defined(BOOST_ASIO_HAS_MOVE)
-    write_at_streambuf_op(const write_at_streambuf_op& other)
-      : streambuf_(other.streambuf_),
-        handler_(other.handler_)
+        handler_(handler)
     {
     }
 
-    write_at_streambuf_op(write_at_streambuf_op&& other)
-      : streambuf_(other.streambuf_),
-        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_transferred)
     {
       streambuf_.consume(bytes_transferred);
       handler_(ec, bytes_transferred);
     }
 
   //private:
     boost::asio::basic_streambuf<Allocator>& streambuf_;
     WriteHandler handler_;
   };
 
-  template <typename Allocator, typename WriteHandler>
+  template <typename AsyncRandomAccessWriteDevice, typename Allocator,
+      typename WriteHandler>
   inline void* asio_handler_allocate(std::size_t size,
-      write_at_streambuf_op<Allocator, WriteHandler>* this_handler)
+      write_at_streambuf_op<AsyncRandomAccessWriteDevice,
+        Allocator, WriteHandler>* this_handler)
   {
     return boost_asio_handler_alloc_helpers::allocate(
         size, this_handler->handler_);
   }
 
-  template <typename Allocator, typename WriteHandler>
+  template <typename AsyncRandomAccessWriteDevice, typename Allocator,
+      typename WriteHandler>
   inline void asio_handler_deallocate(void* pointer, std::size_t size,
-      write_at_streambuf_op<Allocator, WriteHandler>* this_handler)
+      write_at_streambuf_op<AsyncRandomAccessWriteDevice,
+        Allocator, WriteHandler>* this_handler)
   {
     boost_asio_handler_alloc_helpers::deallocate(
         pointer, size, 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_);
-  }
-
-  template <typename Function, typename Allocator, typename WriteHandler>
+  template <typename Function, typename AsyncRandomAccessWriteDevice,
+      typename Allocator, typename WriteHandler>
   inline void asio_handler_invoke(const Function& function,
-      write_at_streambuf_op<Allocator, WriteHandler>* this_handler)
+      write_at_streambuf_op<AsyncRandomAccessWriteDevice,
+        Allocator, WriteHandler>* this_handler)
   {
     boost_asio_handler_invoke_helpers::invoke(
         function, this_handler->handler_);
   }
-
-  template <typename Allocator, typename WriteHandler>
-  inline write_at_streambuf_op<Allocator, WriteHandler>
-  make_write_at_streambuf_op(
-      boost::asio::basic_streambuf<Allocator>& b, WriteHandler handler)
-  {
-    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,
-    CompletionCondition completion_condition,
-    BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
+    CompletionCondition completion_condition, 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;
-
   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<
+        AsyncRandomAccessWriteDevice, Allocator, WriteHandler>(b, handler));
 }
 
 template <typename AsyncRandomAccessWriteDevice, typename Allocator,
     typename WriteHandler>
 inline void async_write_at(AsyncRandomAccessWriteDevice& d,
     boost::uint64_t offset, boost::asio::basic_streambuf<Allocator>& b,
-    BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
+    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;
-
-  async_write_at(d, offset, b.data(), transfer_all(),
-      detail::make_write_at_streambuf_op(
-        b, BOOST_ASIO_MOVE_CAST(WriteHandler)(handler)));
+  async_write_at(d, offset, b, transfer_all(), handler);
 }
 
 #endif // !defined(BOOST_NO_IOSTREAM)
 
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // BOOST_ASIO_IMPL_WRITE_AT_HPP
diff --git a/3rdParty/Boost/src/boost/asio/io_service.hpp b/3rdParty/Boost/src/boost/asio/io_service.hpp
index 43b94e4..a6a27fa 100644
--- a/3rdParty/Boost/src/boost/asio/io_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/io_service.hpp
@@ -1,111 +1,108 @@
 //
 // io_service.hpp
 // ~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_IO_SERVICE_HPP
 #define BOOST_ASIO_IO_SERVICE_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 <stdexcept>
 #include <typeinfo>
 #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__)
 # 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
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 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);
 
 #if defined(BOOST_ASIO_HAS_IOCP)
 namespace detail { typedef win_iocp_io_service io_service_impl; }
 #else
 namespace detail { typedef task_io_service io_service_impl; }
 #endif
 
 /// Provides core I/O functionality.
 /**
  * The io_service class provides the core I/O functionality for users of the
  * asynchronous I/O objects, including:
  *
  * @li boost::asio::ip::tcp::socket
  * @li boost::asio::ip::tcp::acceptor
  * @li boost::asio::ip::udp::socket
  * @li boost::asio::deadline_timer.
  *
  * The io_service class also includes facilities intended for developers of
  * custom asynchronous services.
  *
  * @par Thread Safety
  * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Safe, with the specific exceptions of the reset() and
- * notify_fork() functions. Calling reset() while there are unfinished run(),
- * run_one(), poll() or poll_one() calls results in undefined behaviour. The
- * notify_fork() function should not be called while any io_service function,
- * or any function on an I/O object that is associated with the io_service, is
- * being called in another thread.
+ * @e Shared @e objects: Safe, with the exception that calling reset() while
+ * there are unfinished run(), run_one(), poll() or poll_one() calls results in
+ * undefined behaviour.
  *
  * @par Concepts:
  * Dispatcher.
  *
  * @par Synchronous and asynchronous operations
  *
  * Synchronous operations on I/O objects implicitly run the io_service object
  * for an individual operation. The io_service functions run(), run_one(),
  * poll() or poll_one() must be called for the io_service to perform
  * asynchronous operations on behalf of a C++ program. Notification that an
  * asynchronous operation has completed is delivered by invocation of the
  * associated handler. Handlers are invoked only by a thread that is currently
  * calling any overload of run(), run_one(), poll() or poll_one() for the
  * io_service.
  *
  * @par Effect of exceptions thrown from handlers
  *
  * If an exception is thrown from a handler, the exception is allowed to
  * propagate through the throwing thread's invocation of run(), run_one(),
  * poll() or poll_one(). No other threads that are calling any of these
  * functions are affected. It is then the responsibility of the application to
  * catch the exception.
  *
  * After the exception has been caught, the run(), run_one(), poll() or
  * poll_one() call may be restarted @em without the need for an intervening
  * call to reset(). This allows the thread to rejoin the io_service object's
  * thread pool without impacting any other threads in the pool.
  *
  * For example:
  *
  * @code
  * boost::asio::io_service io_service;
  * ...
  * for (;;)
  * {
@@ -227,364 +224,285 @@ public:
    * @li Uninvoked handler objects that were scheduled for deferred invocation
    * on the io_service, or any associated strand, are destroyed.
    *
    * @li For each service object @c svc in the io_service set, in reverse order
    * of the beginning of service object lifetime, performs
    * <tt>delete static_cast<io_service::service*>(svc)</tt>.
    *
    * @note The destruction sequence described above permits programs to
    * simplify their resource management by using @c shared_ptr<>. Where an
    * object's lifetime is tied to the lifetime of a connection (or some other
    * sequence of asynchronous operations), a @c shared_ptr to the object would
    * be bound into the handlers for all asynchronous operations associated with
    * it. This works as follows:
    *
    * @li When a single connection ends, all associated asynchronous operations
    * complete. The corresponding handler objects are destroyed, and all
    * @c shared_ptr references to the objects are destroyed.
    *
    * @li To shut down the whole program, the io_service function stop() is
    * called to terminate any run() calls as soon as possible. The io_service
    * destructor defined above destroys all handlers, causing all @c shared_ptr
    * references to all connection objects to be destroyed.
    */
   BOOST_ASIO_DECL ~io_service();
 
   /// Run the io_service object's event processing loop.
   /**
    * The run() function blocks until all work has finished and there are no
    * more handlers to be dispatched, or until the io_service has been stopped.
    *
    * Multiple threads may call the run() function to set up a pool of threads
    * from which the io_service may execute handlers. All threads that are
    * waiting in the pool are equivalent and the io_service may choose any one
    * of them to invoke a handler.
    *
-   * A normal exit from the run() function implies that the io_service object
-   * is stopped (the stopped() function returns @c true). Subsequent calls to
-   * run(), run_one(), poll() or poll_one() will return immediately unless there
-   * is a prior call to reset().
+   * The run() function may be safely called again once it has completed only
+   * after a call to reset().
    *
    * @return The number of handlers that were executed.
    *
    * @throws boost::system::system_error Thrown on failure.
    *
    * @note The run() function must not be called from a thread that is currently
    * calling one of run(), run_one(), poll() or poll_one() on the same
    * io_service object.
    *
    * The poll() function may also be used to dispatch ready handlers, but
    * without blocking.
    */
   BOOST_ASIO_DECL std::size_t run();
 
   /// Run the io_service object's event processing loop.
   /**
    * The run() function blocks until all work has finished and there are no
    * more handlers to be dispatched, or until the io_service has been stopped.
    *
    * Multiple threads may call the run() function to set up a pool of threads
    * from which the io_service may execute handlers. All threads that are
    * waiting in the pool are equivalent and the io_service may choose any one
    * of them to invoke a handler.
    *
-   * A normal exit from the run() function implies that the io_service object
-   * is stopped (the stopped() function returns @c true). Subsequent calls to
-   * run(), run_one(), poll() or poll_one() will return immediately unless there
-   * is a prior call to reset().
+   * The run() function may be safely called again once it has completed only
+   * after a call to reset().
    *
    * @param ec Set to indicate what error occurred, if any.
    *
    * @return The number of handlers that were executed.
    *
    * @note The run() function must not be called from a thread that is currently
    * calling one of run(), run_one(), poll() or poll_one() on the same
    * io_service object.
    *
    * The poll() function may also be used to dispatch ready handlers, but
    * without blocking.
    */
   BOOST_ASIO_DECL std::size_t run(boost::system::error_code& ec);
 
   /// Run the io_service object's event processing loop to execute at most one
   /// handler.
   /**
    * The run_one() function blocks until one handler has been dispatched, or
    * until the io_service has been stopped.
    *
-   * @return The number of handlers that were executed. A zero return value
-   * implies that the io_service object is stopped (the stopped() function
-   * returns @c true). Subsequent calls to run(), run_one(), poll() or
-   * poll_one() will return immediately unless there is a prior call to
-   * reset().
+   * @return The number of handlers that were executed.
    *
    * @throws boost::system::system_error Thrown on failure.
    */
   BOOST_ASIO_DECL std::size_t run_one();
 
   /// Run the io_service object's event processing loop to execute at most one
   /// handler.
   /**
    * The run_one() function blocks until one handler has been dispatched, or
    * until the io_service has been stopped.
    *
-   * @return The number of handlers that were executed. A zero return value
-   * implies that the io_service object is stopped (the stopped() function
-   * returns @c true). Subsequent calls to run(), run_one(), poll() or
-   * poll_one() will return immediately unless there is a prior call to
-   * reset().
+   * @param ec Set to indicate what error occurred, if any.
    *
    * @return The number of handlers that were executed.
    */
   BOOST_ASIO_DECL std::size_t run_one(boost::system::error_code& ec);
 
   /// Run the io_service object's event processing loop to execute ready
   /// handlers.
   /**
    * The poll() function runs handlers that are ready to run, without blocking,
    * until the io_service has been stopped or there are no more ready handlers.
    *
    * @return The number of handlers that were executed.
    *
    * @throws boost::system::system_error Thrown on failure.
    */
   BOOST_ASIO_DECL std::size_t poll();
 
   /// Run the io_service object's event processing loop to execute ready
   /// handlers.
   /**
    * The poll() function runs handlers that are ready to run, without blocking,
    * until the io_service has been stopped or there are no more ready handlers.
    *
    * @param ec Set to indicate what error occurred, if any.
    *
    * @return The number of handlers that were executed.
    */
   BOOST_ASIO_DECL std::size_t poll(boost::system::error_code& ec);
 
   /// Run the io_service object's event processing loop to execute one ready
   /// handler.
   /**
    * The poll_one() function runs at most one handler that is ready to run,
    * without blocking.
    *
    * @return The number of handlers that were executed.
    *
    * @throws boost::system::system_error Thrown on failure.
    */
   BOOST_ASIO_DECL std::size_t poll_one();
 
   /// Run the io_service object's event processing loop to execute one ready
   /// handler.
   /**
    * The poll_one() function runs at most one handler that is ready to run,
    * without blocking.
    *
    * @param ec Set to indicate what error occurred, if any.
    *
    * @return The number of handlers that were executed.
    */
   BOOST_ASIO_DECL std::size_t poll_one(boost::system::error_code& ec);
 
   /// Stop the io_service object's event processing loop.
   /**
    * This function does not block, but instead simply signals the io_service to
    * stop. All invocations of its run() or run_one() member functions should
    * return as soon as possible. Subsequent calls to run(), run_one(), poll()
    * or poll_one() will return immediately until reset() is called.
    */
   BOOST_ASIO_DECL void stop();
 
-  /// Determine whether the io_service object has been stopped.
-  /**
-   * This function is used to determine whether an io_service object has been
-   * stopped, either through an explicit call to stop(), or due to running out
-   * of work. When an io_service object is stopped, calls to run(), run_one(),
-   * poll() or poll_one() will return immediately without invoking any
-   * handlers.
-   *
-   * @return @c true if the io_service object is stopped, otherwise @c false.
-   */
-  BOOST_ASIO_DECL bool stopped() const;
-
   /// Reset the io_service in preparation for a subsequent run() invocation.
   /**
    * This function must be called prior to any second or later set of
    * invocations of the run(), run_one(), poll() or poll_one() functions when a
    * previous invocation of these functions returned due to the io_service
-   * being stopped or running out of work. After a call to reset(), the
-   * io_service object's stopped() function will return @c false.
+   * being stopped or running out of work. This function allows the io_service
+   * to reset any internal state, such as a "stopped" flag.
    *
    * This function must not be called while there are any unfinished calls to
    * the run(), run_one(), poll() or poll_one() functions.
    */
   BOOST_ASIO_DECL void reset();
 
   /// Request the io_service to invoke the given handler.
   /**
    * This function is used to ask the io_service to execute the given handler.
    *
    * The io_service guarantees that the handler will only be called in a thread
    * in which the run(), run_one(), poll() or poll_one() member functions is
    * currently being invoked. The handler may be executed inside this function
    * if the guarantee can be met.
    *
    * @param handler The handler to be called. The io_service will make
    * a copy of the handler object as required. The function signature of the
    * handler must be: @code void handler(); @endcode
    *
    * @note This function throws an exception only if:
    *
    * @li the handler's @c asio_handler_allocate function; or
    *
    * @li the handler's copy constructor
    *
    * throws an exception.
    */
   template <typename CompletionHandler>
-  void dispatch(BOOST_ASIO_MOVE_ARG(CompletionHandler) handler);
+  void dispatch(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.
    *
    * The io_service guarantees that the handler will only be called in a thread
    * in which the run(), run_one(), poll() or poll_one() member functions is
    * currently being invoked.
    *
    * @param handler The handler to be called. The io_service will make
    * a copy of the handler object as required. The function signature of the
    * handler must be: @code void handler(); @endcode
    *
    * @note This function throws an exception only if:
    *
    * @li the handler's @c asio_handler_allocate function; or
    *
    * @li the handler's copy constructor
    *
    * throws an exception.
    */
   template <typename CompletionHandler>
-  void post(BOOST_ASIO_MOVE_ARG(CompletionHandler) handler);
+  void post(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
    * object's dispatch function.
    *
    * @param handler The handler to be wrapped. The io_service will make a copy
    * of the handler object as required. The function signature of the handler
    * must be: @code void handler(A1 a1, ... An an); @endcode
    *
    * @return A function object that, when invoked, passes the wrapped handler to
    * the io_service object's dispatch function. Given a function object with the
    * signature:
    * @code R f(A1 a1, ... An an); @endcode
    * If this function object is passed to the wrap function like so:
    * @code io_service.wrap(f); @endcode
    * then the return value is a function object with the signature
    * @code void g(A1 a1, ... An an); @endcode
    * that, when invoked, executes code equivalent to:
    * @code io_service.dispatch(boost::bind(f, a1, ... an)); @endcode
    */
   template <typename Handler>
 #if defined(GENERATING_DOCUMENTATION)
   unspecified
 #else
   detail::wrapped_handler<io_service&, Handler>
 #endif
   wrap(Handler handler);
 
-  /// Fork-related event notifications.
-  enum fork_event
-  {
-    /// Notify the io_service that the process is about to fork.
-    fork_prepare,
-
-    /// Notify the io_service that the process has forked and is the parent.
-    fork_parent,
-
-    /// Notify the io_service that the process has forked and is the child.
-    fork_child
-  };
-
-  /// Notify the io_service of a fork-related event.
-  /**
-   * This function is used to inform the io_service that the process is about
-   * to fork, or has just forked. This allows the io_service, and the services
-   * it contains, to perform any necessary housekeeping to ensure correct
-   * operation following a fork.
-   *
-   * This function must not be called while any other io_service function, or
-   * any function on an I/O object associated with the io_service, is being
-   * called in another thread. It is, however, safe to call this function from
-   * within a completion handler, provided no other thread is accessing the
-   * io_service.
-   *
-   * @param event A fork-related event.
-   *
-   * @throws boost::system::system_error Thrown on failure. If the notification
-   * fails the io_service object should no longer be used and should be
-   * destroyed.
-   *
-   * @par Example
-   * The following code illustrates how to incorporate the notify_fork()
-   * function:
-   * @code my_io_service.notify_fork(boost::asio::io_service::fork_prepare);
-   * if (fork() == 0)
-   * {
-   *   // This is the child process.
-   *   my_io_service.notify_fork(boost::asio::io_service::fork_child);
-   * }
-   * else
-   * {
-   *   // This is the parent process.
-   *   my_io_service.notify_fork(boost::asio::io_service::fork_parent);
-   * } @endcode
-   *
-   * @note For each service object @c svc in the io_service set, performs
-   * <tt>svc->fork_service();</tt>. When processing the fork_prepare event,
-   * services are visited in reverse order of the beginning of service object
-   * lifetime. Otherwise, services are visited in order of the beginning of
-   * service object lifetime.
-   */
-  BOOST_ASIO_DECL void notify_fork(boost::asio::io_service::fork_event event);
-
   /// Obtain the service object corresponding to the given type.
   /**
    * This function is used to locate a service object that corresponds to
    * the given service type. If there is no existing implementation of the
    * service, then the io_service will create a new instance of the service.
    *
    * @param ios The io_service object that owns the service.
    *
    * @return The service interface implementing the specified service type.
    * Ownership of the service interface is not transferred to the caller.
    */
   template <typename Service>
   friend Service& use_service(io_service& ios);
 
   /// Add a service object to the io_service.
   /**
    * This function is used to add a service to the io_service.
    *
    * @param ios The io_service object that owns the service.
    *
    * @param svc The service object. On success, ownership of the service object
    * is transferred to the io_service. When the io_service object is destroyed,
    * it will destroy the service object by performing:
    * @code delete static_cast<io_service::service*>(svc) @endcode
    *
    * @throws boost::asio::service_already_exists Thrown if a service of the
    * given type is already present in the io_service.
    *
    * @throws boost::asio::invalid_service_owner Thrown if the service's owning
    * io_service is not the io_service object specified by the ios parameter.
    */
   template <typename Service>
   friend void add_service(io_service& ios, Service* svc);
 
   /// Determine if an io_service contains a specified service type.
@@ -619,121 +537,120 @@ private:
  * The work class is used to inform the io_service when work starts and
  * finishes. This ensures that the io_service object's run() function will not
  * exit while work is underway, and that it does exit when there is no
  * unfinished work remaining.
  *
  * The work class is copy-constructible so that it may be used as a data member
  * in a handler class. It is not assignable.
  */
 class io_service::work
 {
 public:
   /// Constructor notifies the io_service that work is starting.
   /**
    * The constructor is used to inform the io_service that some work has begun.
    * This ensures that the io_service object's run() function will not exit
    * while the work is underway.
    */
   explicit work(boost::asio::io_service& io_service);
 
   /// Copy constructor notifies the io_service that work is starting.
   /**
    * The constructor is used to inform the io_service that some work has begun.
    * This ensures that the io_service object's run() function will not exit
    * while the work is underway.
    */
   work(const work& other);
 
   /// Destructor notifies the io_service that the work is complete.
   /**
    * The destructor is used to inform the io_service that some work has
    * finished. Once the count of unfinished work reaches zero, the io_service
    * object's run() function is permitted to exit.
    */
   ~work();
 
+  /// (Deprecated: use get_io_service().) Get the io_service associated with the
+  /// work.
+  boost::asio::io_service& io_service();
+
   /// Get the io_service associated with the work.
   boost::asio::io_service& get_io_service();
 
 private:
   // Prevent assignment.
   void operator=(const work& other);
 
-  // The io_service implementation.
-  detail::io_service_impl& io_service_impl_;
+  // The io_service.
+  boost::asio::io_service& io_service_;
 };
 
 /// Class used to uniquely identify a service.
 class io_service::id
   : private noncopyable
 {
 public:
   /// Constructor.
   id() {}
 };
 
 /// Base class for all io_service services.
 class io_service::service
   : private noncopyable
 {
 public:
+  /// (Deprecated: use get_io_service().) Get the io_service object that owns
+  /// the service.
+  boost::asio::io_service& io_service();
+
   /// Get the io_service object that owns the service.
   boost::asio::io_service& get_io_service();
 
 protected:
   /// Constructor.
   /**
    * @param owner The io_service object that owns the service.
    */
   BOOST_ASIO_DECL service(boost::asio::io_service& owner);
 
   /// Destructor.
   BOOST_ASIO_DECL virtual ~service();
 
 private:
   /// Destroy all user-defined handler objects owned by the service.
   virtual void shutdown_service() = 0;
 
-  /// Handle notification of a fork-related event to perform any necessary
-  /// housekeeping.
-  /**
-   * This function is not a pure virtual so that services only have to
-   * implement it if necessary. The default implementation does nothing.
-   */
-  BOOST_ASIO_DECL virtual void fork_service(
-      boost::asio::io_service::fork_event event);
-
   friend class boost::asio::detail::service_registry;
   struct key
   {
     key() : type_info_(0), id_(0) {}
     const std::type_info* type_info_;
     const boost::asio::io_service::id* id_;
   } key_;
 
   boost::asio::io_service& owner_;
   service* next_;
 };
 
 /// Exception thrown when trying to add a duplicate service to an io_service.
 class service_already_exists
   : public std::logic_error
 {
 public:
   BOOST_ASIO_DECL service_already_exists();
 };
 
 /// Exception thrown when trying to add a service object to an io_service where
 /// the service has a different owner.
 class invalid_service_owner
   : public std::logic_error
 {
 public:
   BOOST_ASIO_DECL invalid_service_owner();
 };
 
 namespace detail {
 
 // Special derived service id type to keep classes header-file only.
 template <typename Type>
 class service_id
   : public boost::asio::io_service::id
diff --git a/3rdParty/Boost/src/boost/asio/ip/address.hpp b/3rdParty/Boost/src/boost/asio/ip/address.hpp
index 9e62c04..4ecae7a 100644
--- a/3rdParty/Boost/src/boost/asio/ip/address.hpp
+++ b/3rdParty/Boost/src/boost/asio/ip/address.hpp
@@ -1,164 +1,145 @@
 //
 // ip/address.hpp
 // ~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_IP_ADDRESS_HPP
 #define BOOST_ASIO_IP_ADDRESS_HPP
 
 #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/system/error_code.hpp>
 #include <boost/asio/ip/address_v4.hpp>
 #include <boost/asio/ip/address_v6.hpp>
 
 #if !defined(BOOST_NO_IOSTREAM)
 # include <iosfwd>
 #endif // !defined(BOOST_NO_IOSTREAM)
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace ip {
 
 /// Implements version-independent IP addresses.
 /**
  * The boost::asio::ip::address class provides the ability to use either IP
  * version 4 or version 6 addresses.
  *
  * @par Thread Safety
  * @e Distinct @e objects: Safe.@n
  * @e Shared @e objects: Unsafe.
  */
 class address
 {
 public:
   /// Default constructor.
   BOOST_ASIO_DECL address();
 
   /// Construct an address from an IPv4 address.
   BOOST_ASIO_DECL address(const boost::asio::ip::address_v4& ipv4_address);
 
   /// Construct an address from an IPv6 address.
   BOOST_ASIO_DECL address(const boost::asio::ip::address_v6& ipv6_address);
 
   /// Copy constructor.
   BOOST_ASIO_DECL address(const address& other);
 
-#if defined(BOOST_ASIO_HAS_MOVE)
-  /// Move constructor.
-  BOOST_ASIO_DECL address(address&& other);
-#endif // defined(BOOST_ASIO_HAS_MOVE)
-
   /// Assign from another address.
   BOOST_ASIO_DECL address& operator=(const address& other);
 
-#if defined(BOOST_ASIO_HAS_MOVE)
-  /// Move-assign from another address.
-  BOOST_ASIO_DECL address& operator=(address&& other);
-#endif // defined(BOOST_ASIO_HAS_MOVE)
-
   /// Assign from an IPv4 address.
   BOOST_ASIO_DECL address& operator=(
       const boost::asio::ip::address_v4& ipv4_address);
 
   /// Assign from an IPv6 address.
   BOOST_ASIO_DECL address& operator=(
       const boost::asio::ip::address_v6& ipv6_address);
 
   /// Get whether the address is an IP version 4 address.
   bool is_v4() const
   {
     return type_ == ipv4;
   }
 
   /// Get whether the address is an IP version 6 address.
   bool is_v6() const
   {
     return type_ == ipv6;
   }
 
   /// Get the address as an IP version 4 address.
   BOOST_ASIO_DECL boost::asio::ip::address_v4 to_v4() const;
 
   /// Get the address as an IP version 6 address.
   BOOST_ASIO_DECL boost::asio::ip::address_v6 to_v6() const;
 
   /// Get the address as a string in dotted decimal format.
   BOOST_ASIO_DECL std::string to_string() const;
 
   /// Get the address as a string in dotted decimal format.
   BOOST_ASIO_DECL std::string to_string(boost::system::error_code& ec) const;
 
   /// Create an address from an IPv4 address string in dotted decimal form,
   /// or from an IPv6 address in hexadecimal notation.
   BOOST_ASIO_DECL static address from_string(const char* str);
 
   /// Create an address from an IPv4 address string in dotted decimal form,
   /// or from an IPv6 address in hexadecimal notation.
   BOOST_ASIO_DECL static address from_string(
       const char* str, boost::system::error_code& ec);
 
   /// Create an address from an IPv4 address string in dotted decimal form,
   /// or from an IPv6 address in hexadecimal notation.
   BOOST_ASIO_DECL static address from_string(const std::string& str);
 
   /// Create an address from an IPv4 address string in dotted decimal form,
   /// or from an IPv6 address in hexadecimal notation.
   BOOST_ASIO_DECL static address from_string(
       const std::string& str, boost::system::error_code& ec);
 
-  /// Determine whether the address is a loopback address.
-  BOOST_ASIO_DECL bool is_loopback() const;
-
-  /// Determine whether the address is unspecified.
-  BOOST_ASIO_DECL bool is_unspecified() const;
-
-  /// Determine whether the address is a multicast address.
-  BOOST_ASIO_DECL bool is_multicast() const;
-
   /// Compare two addresses for equality.
   BOOST_ASIO_DECL friend bool operator==(const address& a1, const address& a2);
 
   /// Compare two addresses for inequality.
   friend bool operator!=(const address& a1, const address& a2)
   {
     return !(a1 == a2);
   }
 
   /// Compare addresses for ordering.
   BOOST_ASIO_DECL friend bool operator<(const address& a1, const address& a2);
 
   /// Compare addresses for ordering.
   friend bool operator>(const address& a1, const address& a2)
   {
     return a2 < a1;
   }
 
   /// Compare addresses for ordering.
   friend bool operator<=(const address& a1, const address& a2)
   {
     return !(a2 < a1);
   }
 
   /// Compare addresses for ordering.
   friend bool operator>=(const address& a1, const address& a2)
   {
     return !(a1 < a2);
   }
 
 private:
   // The type of the address.
   enum { ipv4, ipv6 } type_;
 
   // The underlying IPv4 address.
diff --git a/3rdParty/Boost/src/boost/asio/ip/address_v4.hpp b/3rdParty/Boost/src/boost/asio/ip/address_v4.hpp
index 8d11921..5728a17 100644
--- a/3rdParty/Boost/src/boost/asio/ip/address_v4.hpp
+++ b/3rdParty/Boost/src/boost/asio/ip/address_v4.hpp
@@ -1,230 +1,199 @@
 //
 // ip/address_v4.hpp
 // ~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_IP_ADDRESS_V4_HPP
 #define BOOST_ASIO_IP_ADDRESS_V4_HPP
 
 #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/detail/array.hpp>
+#include <boost/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)
 # include <iosfwd>
 #endif // !defined(BOOST_NO_IOSTREAM)
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace ip {
 
 /// Implements IP version 4 style addresses.
 /**
  * The boost::asio::ip::address_v4 class provides the ability to use and
  * manipulate IP version 4 addresses.
  *
  * @par Thread Safety
  * @e Distinct @e objects: Safe.@n
  * @e Shared @e objects: Unsafe.
  */
 class address_v4
 {
 public:
   /// The type used to represent an address as an array of bytes.
-  /**
-   * @note This type is defined in terms of the C++0x template @c std::array
-   * when it is available. Otherwise, it uses @c boost:array.
-   */
-#if defined(GENERATING_DOCUMENTATION)
-  typedef array<unsigned char, 4> bytes_type;
-#else
-  typedef boost::asio::detail::array<unsigned char, 4> bytes_type;
-#endif
+  typedef boost::array<unsigned char, 4> bytes_type;
 
   /// Default constructor.
   address_v4()
   {
     addr_.s_addr = 0;
   }
 
   /// Construct an address from raw bytes.
   BOOST_ASIO_DECL explicit address_v4(const bytes_type& bytes);
 
   /// Construct an address from a unsigned long in host byte order.
   BOOST_ASIO_DECL explicit address_v4(unsigned long addr);
 
   /// Copy constructor.
   address_v4(const address_v4& other)
     : addr_(other.addr_)
   {
   }
 
-#if defined(BOOST_ASIO_HAS_MOVE)
-  /// Move constructor.
-  address_v4(address_v4&& other)
-    : addr_(other.addr_)
-  {
-  }
-#endif // defined(BOOST_ASIO_HAS_MOVE)
-
   /// Assign from another address.
   address_v4& operator=(const address_v4& other)
   {
     addr_ = other.addr_;
     return *this;
   }
 
-#if defined(BOOST_ASIO_HAS_MOVE)
-  /// Move-assign from another address.
-  address_v4& operator=(address_v4&& other)
-  {
-    addr_ = other.addr_;
-    return *this;
-  }
-#endif // defined(BOOST_ASIO_HAS_MOVE)
-
   /// Get the address in bytes, in network byte order.
   BOOST_ASIO_DECL bytes_type to_bytes() const;
 
   /// Get the address as an unsigned long in host byte order
   BOOST_ASIO_DECL unsigned long to_ulong() const;
 
   /// Get the address as a string in dotted decimal format.
   BOOST_ASIO_DECL std::string to_string() const;
 
   /// Get the address as a string in dotted decimal format.
   BOOST_ASIO_DECL std::string to_string(boost::system::error_code& ec) const;
 
   /// Create an address from an IP address string in dotted decimal form.
   BOOST_ASIO_DECL static address_v4 from_string(const char* str);
 
   /// Create an address from an IP address string in dotted decimal form.
   BOOST_ASIO_DECL static address_v4 from_string(
       const char* str, boost::system::error_code& ec);
 
   /// Create an address from an IP address string in dotted decimal form.
   BOOST_ASIO_DECL static address_v4 from_string(const std::string& str);
 
   /// Create an address from an IP address string in dotted decimal form.
   BOOST_ASIO_DECL static address_v4 from_string(
       const std::string& str, boost::system::error_code& ec);
 
-  /// Determine whether the address is a loopback address.
-  BOOST_ASIO_DECL bool is_loopback() const;
-
-  /// Determine whether the address is unspecified.
-  BOOST_ASIO_DECL bool is_unspecified() const;
-
   /// Determine whether the address is a class A address.
   BOOST_ASIO_DECL bool is_class_a() const;
 
   /// Determine whether the address is a class B address.
   BOOST_ASIO_DECL bool is_class_b() const;
 
   /// Determine whether the address is a class C address.
   BOOST_ASIO_DECL bool is_class_c() const;
 
   /// Determine whether the address is a multicast address.
   BOOST_ASIO_DECL bool is_multicast() const;
 
   /// Compare two addresses for equality.
   friend bool operator==(const address_v4& a1, const address_v4& a2)
   {
     return a1.addr_.s_addr == a2.addr_.s_addr;
   }
 
   /// Compare two addresses for inequality.
   friend bool operator!=(const address_v4& a1, const address_v4& a2)
   {
     return a1.addr_.s_addr != a2.addr_.s_addr;
   }
 
   /// Compare addresses for ordering.
   friend bool operator<(const address_v4& a1, const address_v4& a2)
   {
     return a1.to_ulong() < a2.to_ulong();
   }
 
   /// Compare addresses for ordering.
   friend bool operator>(const address_v4& a1, const address_v4& a2)
   {
     return a1.to_ulong() > a2.to_ulong();
   }
 
   /// Compare addresses for ordering.
   friend bool operator<=(const address_v4& a1, const address_v4& a2)
   {
     return a1.to_ulong() <= a2.to_ulong();
   }
 
   /// Compare addresses for ordering.
   friend bool operator>=(const address_v4& a1, const address_v4& a2)
   {
     return a1.to_ulong() >= a2.to_ulong();
   }
 
   /// Obtain an address object that represents any address.
   static address_v4 any()
   {
-    return address_v4();
+    return address_v4(static_cast<unsigned long>(INADDR_ANY));
   }
 
   /// Obtain an address object that represents the loopback address.
   static address_v4 loopback()
   {
-    return address_v4(0x7F000001);
+    return address_v4(static_cast<unsigned long>(INADDR_LOOPBACK));
   }
 
   /// Obtain an address object that represents the broadcast address.
   static address_v4 broadcast()
   {
-    return address_v4(0xFFFFFFFF);
+    return address_v4(static_cast<unsigned long>(INADDR_BROADCAST));
   }
 
   /// Obtain an address object that represents the broadcast address that
   /// corresponds to the specified address and netmask.
   BOOST_ASIO_DECL static address_v4 broadcast(
       const address_v4& addr, const address_v4& mask);
 
   /// Obtain the netmask that corresponds to the address, based on its address
   /// class.
   BOOST_ASIO_DECL static address_v4 netmask(const address_v4& addr);
 
 private:
   // The underlying IPv4 address.
   boost::asio::detail::in4_addr_type addr_;
 };
 
 #if !defined(BOOST_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.
  *
  * @param addr The address to be written.
  *
  * @return The output stream.
  *
  * @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)
diff --git a/3rdParty/Boost/src/boost/asio/ip/address_v6.hpp b/3rdParty/Boost/src/boost/asio/ip/address_v6.hpp
index e35a176..9155bea 100644
--- a/3rdParty/Boost/src/boost/asio/ip/address_v6.hpp
+++ b/3rdParty/Boost/src/boost/asio/ip/address_v6.hpp
@@ -1,116 +1,98 @@
 //
 // ip/address_v6.hpp
 // ~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_IP_ADDRESS_V6_HPP
 #define BOOST_ASIO_IP_ADDRESS_V6_HPP
 
 #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/detail/array.hpp>
+#include <boost/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)
 # include <iosfwd>
 #endif // !defined(BOOST_NO_IOSTREAM)
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace ip {
 
 /// Implements IP version 6 style addresses.
 /**
  * The boost::asio::ip::address_v6 class provides the ability to use and
  * manipulate IP version 6 addresses.
  *
  * @par Thread Safety
  * @e Distinct @e objects: Safe.@n
  * @e Shared @e objects: Unsafe.
  */
 class address_v6
 {
 public:
   /// The type used to represent an address as an array of bytes.
-  /**
-   * @note This type is defined in terms of the C++0x template @c std::array
-   * when it is available. Otherwise, it uses @c boost:array.
-   */
-#if defined(GENERATING_DOCUMENTATION)
-  typedef array<unsigned char, 16> bytes_type;
-#else
-  typedef boost::asio::detail::array<unsigned char, 16> bytes_type;
-#endif
+  typedef boost::array<unsigned char, 16> bytes_type;
 
   /// Default constructor.
   BOOST_ASIO_DECL address_v6();
 
   /// Construct an address from raw bytes and scope ID.
   BOOST_ASIO_DECL explicit address_v6(const bytes_type& bytes,
       unsigned long scope_id = 0);
 
   /// Copy constructor.
   BOOST_ASIO_DECL address_v6(const address_v6& other);
 
-#if defined(BOOST_ASIO_HAS_MOVE)
-  /// Move constructor.
-  BOOST_ASIO_DECL address_v6(address_v6&& other);
-#endif // defined(BOOST_ASIO_HAS_MOVE)
-
   /// Assign from another address.
   BOOST_ASIO_DECL address_v6& operator=(const address_v6& other);
 
-#if defined(BOOST_ASIO_HAS_MOVE)
-  /// Move-assign from another address.
-  BOOST_ASIO_DECL address_v6& operator=(address_v6&& other);
-#endif // defined(BOOST_ASIO_HAS_MOVE)
-
   /// The scope ID of the address.
   /**
    * Returns the scope ID associated with the IPv6 address.
    */
   unsigned long scope_id() const
   {
     return scope_id_;
   }
 
   /// The scope ID of the address.
   /**
    * Modifies the scope ID associated with the IPv6 address.
    */
   void scope_id(unsigned long id)
   {
     scope_id_ = id;
   }
 
   /// Get the address in bytes, in network byte order.
   BOOST_ASIO_DECL bytes_type to_bytes() const;
 
   /// Get the address as a string.
   BOOST_ASIO_DECL std::string to_string() const;
 
   /// Get the address as a string.
   BOOST_ASIO_DECL std::string to_string(boost::system::error_code& ec) const;
 
   /// Create an address from an IP address string.
   BOOST_ASIO_DECL static address_v6 from_string(const char* str);
 
   /// Create an address from an IP address string.
   BOOST_ASIO_DECL static address_v6 from_string(
       const char* str, boost::system::error_code& ec);
 
   /// Create an address from an IP address string.
diff --git a/3rdParty/Boost/src/boost/asio/ip/basic_endpoint.hpp b/3rdParty/Boost/src/boost/asio/ip/basic_endpoint.hpp
index 9eefe4c..0047adc 100644
--- a/3rdParty/Boost/src/boost/asio/ip/basic_endpoint.hpp
+++ b/3rdParty/Boost/src/boost/asio/ip/basic_endpoint.hpp
@@ -1,40 +1,40 @@
 //
 // ip/basic_endpoint.hpp
 // ~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_IP_BASIC_ENDPOINT_HPP
 #define BOOST_ASIO_IP_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/ip/address.hpp>
 #include <boost/asio/ip/detail/endpoint.hpp>
 
 #if !defined(BOOST_NO_IOSTREAM)
 # include <iosfwd>
 #endif // !defined(BOOST_NO_IOSTREAM)
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace ip {
 
 /// Describes an endpoint for a version-independent IP socket.
 /**
  * The boost::asio::ip::basic_endpoint class template describes an endpoint that
  * may be associated with a particular socket.
  *
  * @par Thread Safety
  * @e Distinct @e objects: Safe.@n
  * @e Shared @e objects: Unsafe.
  *
@@ -46,144 +46,126 @@ class basic_endpoint
 {
 public:
   /// The protocol type associated with the endpoint.
   typedef InternetProtocol 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()
     : impl_()
   {
   }
 
   /// Construct an endpoint using a port number, specified in the host's byte
   /// order. The IP address will be the any address (i.e. INADDR_ANY or
   /// in6addr_any). This constructor would typically be used for accepting new
   /// connections.
   /**
    * @par Examples
    * To initialise an IPv4 TCP endpoint for port 1234, use:
    * @code
    * boost::asio::ip::tcp::endpoint ep(boost::asio::ip::tcp::v4(), 1234);
    * @endcode
    *
    * To specify an IPv6 UDP endpoint for port 9876, use:
    * @code
    * boost::asio::ip::udp::endpoint ep(boost::asio::ip::udp::v6(), 9876);
    * @endcode
    */
-  basic_endpoint(const InternetProtocol& internet_protocol,
-      unsigned short port_num)
-    : impl_(internet_protocol.family(), port_num)
+  basic_endpoint(const InternetProtocol& protocol, unsigned short port_num)
+    : impl_(protocol.family(), port_num)
   {
   }
 
   /// Construct an endpoint using a port number and an IP address. This
   /// constructor may be used for accepting connections on a specific interface
   /// or for making a connection to a remote endpoint.
   basic_endpoint(const boost::asio::ip::address& addr, unsigned short port_num)
     : impl_(addr, port_num)
   {
   }
 
   /// 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
   {
     if (impl_.is_v4())
       return InternetProtocol::v4();
     return InternetProtocol::v6();
   }
 
   /// 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)
+  void resize(std::size_t size)
   {
-    impl_.resize(new_size);
+    impl_.resize(size);
   }
 
   /// Get the capacity of the endpoint in the native type.
   std::size_t capacity() const
   {
     return impl_.capacity();
   }
 
   /// Get the port associated with the endpoint. The port number is always in
   /// the host's byte order.
   unsigned short port() const
   {
     return impl_.port();
   }
 
   /// Set the port associated with the endpoint. The port number is always in
   /// the host's byte order.
   void port(unsigned short port_num)
   {
     impl_.port(port_num);
   }
 
   /// Get the IP address associated with the endpoint.
   boost::asio::ip::address address() const
   {
     return impl_.address();
   }
 
   /// Set the IP address associated with the endpoint.
   void address(const boost::asio::ip::address& addr)
   {
     impl_.address(addr);
   }
 
   /// Compare two endpoints for equality.
diff --git a/3rdParty/Boost/src/boost/asio/ip/basic_resolver.hpp b/3rdParty/Boost/src/boost/asio/ip/basic_resolver.hpp
index 6265890..f27515a 100644
--- a/3rdParty/Boost/src/boost/asio/ip/basic_resolver.hpp
+++ b/3rdParty/Boost/src/boost/asio/ip/basic_resolver.hpp
@@ -1,55 +1,54 @@
 //
 // ip/basic_resolver.hpp
 // ~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_IP_BASIC_RESOLVER_HPP
 #define BOOST_ASIO_IP_BASIC_RESOLVER_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/basic_io_object.hpp>
-#include <boost/asio/detail/handler_type_requirements.hpp>
 #include <boost/asio/detail/throw_error.hpp>
 #include <boost/asio/error.hpp>
 #include <boost/asio/ip/basic_resolver_iterator.hpp>
 #include <boost/asio/ip/basic_resolver_query.hpp>
 #include <boost/asio/ip/resolver_service.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace ip {
 
 /// Provides endpoint resolution functionality.
 /**
  * The basic_resolver class template provides the ability to resolve a query
  * to a list of endpoints.
  *
  * @par Thread Safety
  * @e Distinct @e objects: Safe.@n
  * @e Shared @e objects: Unsafe.
  */
 template <typename InternetProtocol,
     typename ResolverService = resolver_service<InternetProtocol> >
 class basic_resolver
   : public basic_io_object<ResolverService>
 {
 public:
   /// The protocol type.
   typedef InternetProtocol protocol_type;
 
   /// The endpoint type.
   typedef typename InternetProtocol::endpoint endpoint_type;
 
   /// The query type.
   typedef basic_resolver_query<InternetProtocol> query;
@@ -68,199 +67,185 @@ public:
     : basic_io_object<ResolverService>(io_service)
   {
   }
 
   /// Cancel any asynchronous operations that are waiting on the resolver.
   /**
    * This function forces the completion of any pending asynchronous
    * operations on the host resolver. The handler for each cancelled operation
    * will be invoked with the boost::asio::error::operation_aborted error code.
    */
   void cancel()
   {
     return this->service.cancel(this->implementation);
   }
 
   /// Perform forward resolution of a query to a list of entries.
   /**
    * This function is used to resolve a query into a list of endpoint entries.
    *
    * @param q A query object that determines what endpoints will be returned.
    *
    * @returns A forward-only iterator that can be used to traverse the list
    * of endpoint entries.
    *
    * @throws boost::system::system_error Thrown on failure.
    *
    * @note A default constructed iterator represents the end of the list.
    *
    * A successful call to this function is guaranteed to return at least one
    * entry.
    */
   iterator resolve(const query& q)
   {
     boost::system::error_code ec;
     iterator i = this->service.resolve(this->implementation, q, ec);
-    boost::asio::detail::throw_error(ec, "resolve");
+    boost::asio::detail::throw_error(ec);
     return i;
   }
 
   /// Perform forward resolution of a query to a list of entries.
   /**
    * This function is used to resolve a query into a list of endpoint entries.
    *
    * @param q A query object that determines what endpoints will be returned.
    *
    * @param ec Set to indicate what error occurred, if any.
    *
    * @returns A forward-only iterator that can be used to traverse the list
    * of endpoint entries. Returns a default constructed iterator if an error
    * occurs.
    *
    * @note A default constructed iterator represents the end of the list.
    *
    * A successful call to this function is guaranteed to return at least one
    * entry.
    */
   iterator resolve(const query& q, boost::system::error_code& ec)
   {
     return this->service.resolve(this->implementation, q, ec);
   }
 
   /// Asynchronously perform forward resolution of a query to a list of entries.
   /**
    * This function is used to asynchronously resolve a query into a list of
    * endpoint entries.
    *
    * @param q A query object that determines what endpoints will be returned.
    *
    * @param handler The handler to be called when the resolve operation
    * completes. Copies will be made of the handler as required. The function
    * signature of the handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
    *   resolver::iterator iterator             // Forward-only iterator that can
    *                                           // be used to traverse the list
    *                                           // of endpoint entries.
    * ); @endcode
    * 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().
    *
    * @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_MOVE_ARG(ResolveHandler) handler)
+  void async_resolve(const query& q, 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;
-
-    return this->service.async_resolve(this->implementation, q,
-        BOOST_ASIO_MOVE_CAST(ResolveHandler)(handler));
+    return this->service.async_resolve(this->implementation, q, handler);
   }
 
   /// Perform reverse resolution of an endpoint to a list of entries.
   /**
    * This function is used to resolve an endpoint into a list of endpoint
    * entries.
    *
    * @param e An endpoint object that determines what endpoints will be
    * returned.
    *
    * @returns A forward-only iterator that can be used to traverse the list
    * of endpoint entries.
    *
    * @throws boost::system::system_error Thrown on failure.
    *
    * @note A default constructed iterator represents the end of the list.
    *
    * A successful call to this function is guaranteed to return at least one
    * entry.
    */
   iterator resolve(const endpoint_type& e)
   {
     boost::system::error_code ec;
     iterator i = this->service.resolve(this->implementation, e, ec);
-    boost::asio::detail::throw_error(ec, "resolve");
+    boost::asio::detail::throw_error(ec);
     return i;
   }
 
   /// Perform reverse resolution of an endpoint to a list of entries.
   /**
    * This function is used to resolve an endpoint into a list of endpoint
    * entries.
    *
    * @param e An endpoint object that determines what endpoints will be
    * returned.
    *
    * @param ec Set to indicate what error occurred, if any.
    *
    * @returns A forward-only iterator that can be used to traverse the list
    * of endpoint entries. Returns a default constructed iterator if an error
    * occurs.
    *
    * @note A default constructed iterator represents the end of the list.
    *
    * A successful call to this function is guaranteed to return at least one
    * entry.
    */
   iterator resolve(const endpoint_type& e, boost::system::error_code& ec)
   {
     return this->service.resolve(this->implementation, e, ec);
   }
 
   /// Asynchronously perform reverse resolution of an endpoint to a list of
   /// entries.
   /**
    * This function is used to asynchronously resolve an endpoint into a list of
    * endpoint entries.
    *
    * @param e An endpoint object that determines what endpoints will be
    * returned.
    *
    * @param handler The handler to be called when the resolve operation
    * completes. Copies will be made of the handler as required. The function
    * signature of the handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
    *   resolver::iterator iterator             // Forward-only iterator that can
    *                                           // be used to traverse the list
    *                                           // of endpoint entries.
    * ); @endcode
    * 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().
    *
    * @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_MOVE_ARG(ResolveHandler) handler)
+  void async_resolve(const endpoint_type& e, 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;
-
-    return this->service.async_resolve(this->implementation, e,
-        BOOST_ASIO_MOVE_CAST(ResolveHandler)(handler));
+    return this->service.async_resolve(this->implementation, e, handler);
   }
 };
 
 } // namespace ip
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // BOOST_ASIO_IP_BASIC_RESOLVER_HPP
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..980b488 100644
--- a/3rdParty/Boost/src/boost/asio/ip/basic_resolver_entry.hpp
+++ b/3rdParty/Boost/src/boost/asio/ip/basic_resolver_entry.hpp
@@ -1,91 +1,91 @@
 //
 // ip/basic_resolver_entry.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_IP_BASIC_RESOLVER_ENTRY_HPP
 #define BOOST_ASIO_IP_BASIC_RESOLVER_ENTRY_HPP
 
 #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/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace ip {
 
 /// An entry produced by a resolver.
 /**
  * The boost::asio::ip::basic_resolver_entry class template describes an entry
  * as returned by a resolver.
  *
  * @par Thread Safety
  * @e Distinct @e objects: Safe.@n
  * @e Shared @e objects: Unsafe.
  */
 template <typename InternetProtocol>
 class basic_resolver_entry
 {
 public:
   /// The protocol type associated with the endpoint entry.
   typedef InternetProtocol protocol_type;
 
   /// The endpoint type associated with the endpoint entry.
   typedef typename InternetProtocol::endpoint endpoint_type;
 
   /// Default constructor.
   basic_resolver_entry()
   {
   }
 
   /// Construct with specified endpoint, host name and service name.
-  basic_resolver_entry(const endpoint_type& ep,
-      const std::string& host, const std::string& service)
-    : endpoint_(ep),
-      host_name_(host),
-      service_name_(service)
+  basic_resolver_entry(const endpoint_type& endpoint,
+      const std::string& host_name, const std::string& service_name)
+    : endpoint_(endpoint),
+      host_name_(host_name),
+      service_name_(service_name)
   {
   }
 
   /// Get the endpoint associated with the entry.
   endpoint_type endpoint() const
   {
     return endpoint_;
   }
 
   /// Convert to the endpoint associated with the entry.
   operator endpoint_type() const
   {
     return endpoint_;
   }
 
   /// Get the host name associated with the entry.
   std::string host_name() const
   {
     return host_name_;
   }
 
   /// Get the service name associated with the entry.
   std::string service_name() const
   {
     return service_name_;
   }
 
 private:
   endpoint_type endpoint_;
   std::string host_name_;
   std::string service_name_;
 };
 
 } // namespace ip
 } // namespace asio
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..465c278 100644
--- a/3rdParty/Boost/src/boost/asio/ip/basic_resolver_iterator.hpp
+++ b/3rdParty/Boost/src/boost/asio/ip/basic_resolver_iterator.hpp
@@ -1,100 +1,91 @@
 //
 // ip/basic_resolver_iterator.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_IP_BASIC_RESOLVER_ITERATOR_HPP
 #define BOOST_ASIO_IP_BASIC_RESOLVER_ITERATOR_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/iterator.hpp>
 #include <cstring>
-#include <iterator>
 #include <string>
 #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>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace ip {
 
 /// An iterator over the entries produced by a resolver.
 /**
  * The boost::asio::ip::basic_resolver_iterator class template is used to define
  * iterators over the results returned by a resolver.
  *
  * The iterator's value_type, obtained when the iterator is dereferenced, is:
  * @code const basic_resolver_entry<InternetProtocol> @endcode
  *
  * @par Thread Safety
  * @e Distinct @e objects: Safe.@n
  * @e Shared @e objects: Unsafe.
  */
 template <typename InternetProtocol>
 class basic_resolver_iterator
+#if defined(GENERATING_DOCUMENTATION)
+  : public std::iterator<
+#else // defined(GENERATING_DOCUMENTATION)
+  : public boost::iterator<
+#endif // defined(GENERATING_DOCUMENTATION)
+      std::forward_iterator_tag,
+      const basic_resolver_entry<InternetProtocol> >
 {
 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 basic_resolver_entry<InternetProtocol> value_type;
-
-  /// The type of the result of applying operator->() to the iterator.
-  typedef const basic_resolver_entry<InternetProtocol>* pointer;
-
-  /// The type of the result of applying operator*() to the iterator.
-  typedef const basic_resolver_entry<InternetProtocol>& reference;
-
-  /// The iterator category.
-  typedef std::forward_iterator_tag iterator_category;
-
   /// Default constructor creates an end iterator.
   basic_resolver_iterator()
     : index_(0)
   {
   }
 
   /// Create an iterator from an addrinfo list returned by getaddrinfo.
   static basic_resolver_iterator create(
       boost::asio::detail::addrinfo_type* address_info,
       const std::string& host_name, const std::string& service_name)
   {
     basic_resolver_iterator iter;
     if (!address_info)
       return iter;
 
     std::string actual_host_name = host_name;
     if (address_info->ai_canonname)
       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)
       {
         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);
         iter.values_->push_back(
             basic_resolver_entry<InternetProtocol>(endpoint,
               actual_host_name, service_name));
       }
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..8fd63bc 100644
--- a/3rdParty/Boost/src/boost/asio/ip/basic_resolver_query.hpp
+++ b/3rdParty/Boost/src/boost/asio/ip/basic_resolver_query.hpp
@@ -1,239 +1,240 @@
 //
 // ip/basic_resolver_query.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_IP_BASIC_RESOLVER_QUERY_HPP
 #define BOOST_ASIO_IP_BASIC_RESOLVER_QUERY_HPP
 
 #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/detail/socket_ops.hpp>
 #include <boost/asio/ip/resolver_query_base.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace ip {
 
 /// An query to be passed to a resolver.
 /**
  * The boost::asio::ip::basic_resolver_query class template describes a query
  * that can be passed to a resolver.
  *
  * @par Thread Safety
  * @e Distinct @e objects: Safe.@n
  * @e Shared @e objects: Unsafe.
  */
 template <typename InternetProtocol>
 class basic_resolver_query
   : public resolver_query_base
 {
 public:
   /// The protocol type associated with the endpoint query.
   typedef InternetProtocol protocol_type;
 
   /// Construct with specified service name for any protocol.
   /**
    * This constructor is typically used to perform name resolution for local
    * service binding.
    *
-   * @param service A string identifying the requested service. This may be a
-   * descriptive name or a numeric string corresponding to a port number.
+   * @param service_name A string identifying the requested service. This may
+   * be a descriptive name or a numeric string corresponding to a port number.
    *
    * @param resolve_flags A set of flags that determine how name resolution
    * should be performed. The default flags are suitable for local service
    * binding.
    *
    * @note On POSIX systems, service names are typically defined in the file
    * <tt>/etc/services</tt>. On Windows, service names may be found in the file
    * <tt>c:\\windows\\system32\\drivers\\etc\\services</tt>. Operating systems
    * may use additional locations when resolving service names.
    */
-  basic_resolver_query(const std::string& service,
+  basic_resolver_query(const std::string& service_name,
       resolver_query_base::flags resolve_flags = passive | address_configured)
     : hints_(),
       host_name_(),
-      service_name_(service)
+      service_name_(service_name)
   {
     typename InternetProtocol::endpoint endpoint;
     hints_.ai_flags = static_cast<int>(resolve_flags);
     hints_.ai_family = PF_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;
   }
 
   /// Construct with specified service name for a given protocol.
   /**
    * This constructor is typically used to perform name resolution for local
    * service binding with a specific protocol version.
    *
    * @param protocol A protocol object, normally representing either the IPv4 or
    * IPv6 version of an internet protocol.
    *
-   * @param service A string identifying the requested service. This may be a
-   * descriptive name or a numeric string corresponding to a port number.
+   * @param service_name A string identifying the requested service. This may
+   * be a descriptive name or a numeric string corresponding to a port number.
    *
    * @param resolve_flags A set of flags that determine how name resolution
    * should be performed. The default flags are suitable for local service
    * binding.
    *
    * @note On POSIX systems, service names are typically defined in the file
    * <tt>/etc/services</tt>. On Windows, service names may be found in the file
    * <tt>c:\\windows\\system32\\drivers\\etc\\services</tt>. Operating systems
    * may use additional locations when resolving service names.
    */
   basic_resolver_query(const protocol_type& protocol,
-      const std::string& service,
+      const std::string& service_name,
       resolver_query_base::flags resolve_flags = passive | address_configured)
     : hints_(),
       host_name_(),
-      service_name_(service)
+      service_name_(service_name)
   {
     hints_.ai_flags = static_cast<int>(resolve_flags);
     hints_.ai_family = protocol.family();
     hints_.ai_socktype = protocol.type();
     hints_.ai_protocol = protocol.protocol();
     hints_.ai_addrlen = 0;
     hints_.ai_canonname = 0;
     hints_.ai_addr = 0;
     hints_.ai_next = 0;
   }
 
   /// Construct with specified host name and service name for any protocol.
   /**
    * This constructor is typically used to perform name resolution for
    * communication with remote hosts.
    *
-   * @param host A string identifying a location. May be a descriptive name or
-   * a numeric address string. If an empty string and the passive flag has been
-   * specified, the resolved endpoints are suitable for local service binding.
-   * If an empty string and passive is not specified, the resolved endpoints
-   * will use the loopback address.
+   * @param host_name A string identifying a location. May be a descriptive name
+   * or a numeric address string. If an empty string and the passive flag has
+   * been specified, the resolved endpoints are suitable for local service
+   * binding. If an empty string and passive is not specified, the resolved
+   * endpoints will use the loopback address.
    *
-   * @param service A string identifying the requested service. This may be a
-   * descriptive name or a numeric string corresponding to a port number. May
-   * be an empty string, in which case all resolved endpoints will have a port
-   * number of 0.
+   * @param service_name A string identifying the requested service. This may
+   * be a descriptive name or a numeric string corresponding to a port number.
+   * May be an empty string, in which case all resolved endpoints will have a
+   * port number of 0.
    *
    * @param resolve_flags A set of flags that determine how name resolution
    * should be performed. The default flags are suitable for communication with
    * remote hosts.
    *
    * @note On POSIX systems, host names may be locally defined in the file
    * <tt>/etc/hosts</tt>. On Windows, host names may be defined in the file
    * <tt>c:\\windows\\system32\\drivers\\etc\\hosts</tt>. Remote host name
    * resolution is performed using DNS. Operating systems may use additional
    * locations when resolving host names (such as NETBIOS names on Windows).
    *
    * On POSIX systems, service names are typically defined in the file
    * <tt>/etc/services</tt>. On Windows, service names may be found in the file
    * <tt>c:\\windows\\system32\\drivers\\etc\\services</tt>. Operating systems
    * may use additional locations when resolving service names.
    */
-  basic_resolver_query(const std::string& host, const std::string& service,
+  basic_resolver_query(const std::string& host_name,
+      const std::string& service_name,
       resolver_query_base::flags resolve_flags = address_configured)
     : hints_(),
-      host_name_(host),
-      service_name_(service)
+      host_name_(host_name),
+      service_name_(service_name)
   {
     typename InternetProtocol::endpoint endpoint;
     hints_.ai_flags = static_cast<int>(resolve_flags);
     hints_.ai_family = PF_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;
   }
 
   /// Construct with specified host name and service name for a given protocol.
   /**
    * This constructor is typically used to perform name resolution for
    * communication with remote hosts.
    *
    * @param protocol A protocol object, normally representing either the IPv4 or
    * IPv6 version of an internet protocol.
    *
-   * @param host A string identifying a location. May be a descriptive name or
-   * a numeric address string. If an empty string and the passive flag has been
-   * specified, the resolved endpoints are suitable for local service binding.
-   * If an empty string and passive is not specified, the resolved endpoints
-   * will use the loopback address.
+   * @param host_name A string identifying a location. May be a descriptive name
+   * or a numeric address string. If an empty string and the passive flag has
+   * been specified, the resolved endpoints are suitable for local service
+   * binding. If an empty string and passive is not specified, the resolved
+   * endpoints will use the loopback address.
    *
-   * @param service A string identifying the requested service. This may be a
-   * descriptive name or a numeric string corresponding to a port number. May
-   * be an empty string, in which case all resolved endpoints will have a port
-   * number of 0.
+   * @param service_name A string identifying the requested service. This may
+   * be a descriptive name or a numeric string corresponding to a port number.
+   * May be an empty string, in which case all resolved endpoints will have a
+   * port number of 0.
    *
    * @param resolve_flags A set of flags that determine how name resolution
    * should be performed. The default flags are suitable for communication with
    * remote hosts.
    *
    * @note On POSIX systems, host names may be locally defined in the file
    * <tt>/etc/hosts</tt>. On Windows, host names may be defined in the file
    * <tt>c:\\windows\\system32\\drivers\\etc\\hosts</tt>. Remote host name
    * resolution is performed using DNS. Operating systems may use additional
    * locations when resolving host names (such as NETBIOS names on Windows).
    *
    * On POSIX systems, service names are typically defined in the file
    * <tt>/etc/services</tt>. On Windows, service names may be found in the file
    * <tt>c:\\windows\\system32\\drivers\\etc\\services</tt>. Operating systems
    * may use additional locations when resolving service names.
    */
   basic_resolver_query(const protocol_type& protocol,
-      const std::string& host, const std::string& service,
+      const std::string& host_name, const std::string& service_name,
       resolver_query_base::flags resolve_flags = address_configured)
     : hints_(),
-      host_name_(host),
-      service_name_(service)
+      host_name_(host_name),
+      service_name_(service_name)
   {
     hints_.ai_flags = static_cast<int>(resolve_flags);
     hints_.ai_family = protocol.family();
     hints_.ai_socktype = protocol.type();
     hints_.ai_protocol = protocol.protocol();
     hints_.ai_addrlen = 0;
     hints_.ai_canonname = 0;
     hints_.ai_addr = 0;
     hints_.ai_next = 0;
   }
 
   /// Get the hints associated with the query.
   const boost::asio::detail::addrinfo_type& hints() const
   {
     return hints_;
   }
 
   /// Get the host name associated with the query.
   std::string host_name() const
   {
     return host_name_;
   }
 
   /// Get the service name associated with the query.
   std::string service_name() const
   {
     return service_name_;
   }
 
 private:
   boost::asio::detail::addrinfo_type hints_;
   std::string host_name_;
   std::string service_name_;
 };
 
diff --git a/3rdParty/Boost/src/boost/asio/ip/detail/endpoint.hpp b/3rdParty/Boost/src/boost/asio/ip/detail/endpoint.hpp
index 04335ef..fe95a00 100644
--- a/3rdParty/Boost/src/boost/asio/ip/detail/endpoint.hpp
+++ b/3rdParty/Boost/src/boost/asio/ip/detail/endpoint.hpp
@@ -1,40 +1,40 @@
 //
 // ip/detail/endpoint.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_IP_DETAIL_ENDPOINT_HPP
 #define BOOST_ASIO_IP_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 <string>
 #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.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace ip {
 namespace detail {
 
 // Helper class for implementating an IP endpoint.
 class endpoint
 {
 public:
   // Default constructor.
   BOOST_ASIO_DECL endpoint();
 
   // Construct an endpoint using a family and port number.
   BOOST_ASIO_DECL endpoint(int family, unsigned short port_num);
@@ -46,96 +46,97 @@ public:
   // Copy constructor.
   endpoint(const endpoint& other)
     : data_(other.data_)
   {
   }
 
   // Assign from another endpoint.
   endpoint& operator=(const endpoint& other)
   {
     data_ = other.data_;
     return *this;
   }
 
   // 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
   {
     if (is_v4())
       return sizeof(boost::asio::detail::sockaddr_in4_type);
     else
       return sizeof(boost::asio::detail::sockaddr_in6_type);
   }
 
   // Set the underlying size of the endpoint in the native type.
-  BOOST_ASIO_DECL void resize(std::size_t new_size);
+  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(data_);
+    return sizeof(boost::asio::detail::sockaddr_storage_type);
   }
 
   // Get the port associated with the endpoint.
   BOOST_ASIO_DECL unsigned short port() const;
 
   // Set the port associated with the endpoint.
   BOOST_ASIO_DECL void port(unsigned short port_num);
 
   // Get the IP address associated with the endpoint.
   BOOST_ASIO_DECL boost::asio::ip::address address() const;
 
   // Set the IP address associated with the endpoint.
   BOOST_ASIO_DECL void address(const boost::asio::ip::address& addr);
 
   // 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);
 
   // Determine whether the endpoint is IPv4.
   bool is_v4() const
   {
     return data_.base.sa_family == AF_INET;
   }
 
 #if !defined(BOOST_NO_IOSTREAM)
   // Convert to a string.
   BOOST_ASIO_DECL std::string to_string(boost::system::error_code& ec) const;
 #endif // !defined(BOOST_NO_IOSTREAM)
 
 private:
   // The underlying IP socket address.
   union data_union
   {
     boost::asio::detail::socket_addr_type base;
+    boost::asio::detail::sockaddr_storage_type storage;
     boost::asio::detail::sockaddr_in4_type v4;
     boost::asio::detail::sockaddr_in6_type v6;
   } data_;
 };
 
 } // namespace detail
 } // namespace ip
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #if defined(BOOST_ASIO_HEADER_ONLY)
 # include <boost/asio/ip/detail/impl/endpoint.ipp>
 #endif // defined(BOOST_ASIO_HEADER_ONLY)
 
 #endif // BOOST_ASIO_IP_DETAIL_ENDPOINT_HPP
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..0443d38 100644
--- a/3rdParty/Boost/src/boost/asio/ip/detail/impl/endpoint.ipp
+++ b/3rdParty/Boost/src/boost/asio/ip/detail/impl/endpoint.ipp
@@ -1,187 +1,177 @@
 //
 // ip/detail/impl/endpoint.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_IP_DETAIL_IMPL_ENDPOINT_IPP
 #define BOOST_ASIO_IP_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>
 #if !defined(BOOST_NO_IOSTREAM)
 # include <sstream>
 #endif // !defined(BOOST_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>
 
 namespace boost {
 namespace asio {
 namespace ip {
 namespace detail {
 
 endpoint::endpoint()
   : data_()
 {
   data_.v4.sin_family = AF_INET;
   data_.v4.sin_port = 0;
   data_.v4.sin_addr.s_addr = INADDR_ANY;
 }
 
 endpoint::endpoint(int family, unsigned short port_num)
   : data_()
 {
   using namespace std; // For memcpy.
   if (family == PF_INET)
   {
     data_.v4.sin_family = 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;
   }
   else
   {
     data_.v6.sin6_family = 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;
-    data_.v6.sin6_addr.s6_addr[6] = 0, data_.v6.sin6_addr.s6_addr[7] = 0;
-    data_.v6.sin6_addr.s6_addr[8] = 0, data_.v6.sin6_addr.s6_addr[9] = 0;
-    data_.v6.sin6_addr.s6_addr[10] = 0, data_.v6.sin6_addr.s6_addr[11] = 0;
-    data_.v6.sin6_addr.s6_addr[12] = 0, data_.v6.sin6_addr.s6_addr[13] = 0;
-    data_.v6.sin6_addr.s6_addr[14] = 0, data_.v6.sin6_addr.s6_addr[15] = 0;
+    boost::asio::detail::in6_addr_type tmp_addr = IN6ADDR_ANY_INIT;
+    data_.v6.sin6_addr = tmp_addr;
     data_.v6.sin6_scope_id = 0;
   }
 }
 
 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_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());
   }
   else
   {
     data_.v6.sin6_family = 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);
+    memcpy(data_.v6.sin6_addr.s6_addr, bytes.elems, 16);
     data_.v6.sin6_scope_id = v6_addr.scope_id();
   }
 }
 
-void endpoint::resize(std::size_t new_size)
+void endpoint::resize(std::size_t size)
 {
-  if (new_size > sizeof(boost::asio::detail::sockaddr_storage_type))
+  if (size > sizeof(boost::asio::detail::sockaddr_storage_type))
   {
     boost::system::error_code ec(boost::asio::error::invalid_argument);
     boost::asio::detail::throw_error(ec);
   }
 }
 
 unsigned short endpoint::port() const
 {
   if (is_v4())
   {
     return boost::asio::detail::socket_ops::network_to_host_short(
         data_.v4.sin_port);
   }
   else
   {
     return boost::asio::detail::socket_ops::network_to_host_short(
         data_.v6.sin6_port);
   }
 }
 
 void endpoint::port(unsigned short port_num)
 {
   if (is_v4())
   {
     data_.v4.sin_port
       = boost::asio::detail::socket_ops::host_to_network_short(port_num);
   }
   else
   {
     data_.v6.sin6_port
       = boost::asio::detail::socket_ops::host_to_network_short(port_num);
   }
 }
 
 boost::asio::ip::address endpoint::address() const
 {
   using namespace std; // For memcpy.
   if (is_v4())
   {
     return boost::asio::ip::address_v4(
         boost::asio::detail::socket_ops::network_to_host_long(
           data_.v4.sin_addr.s_addr));
   }
   else
   {
     boost::asio::ip::address_v6::bytes_type bytes;
-#if defined(BOOST_ASIO_HAS_STD_ARRAY)
-    memcpy(bytes.data(), data_.v6.sin6_addr.s6_addr, 16);
-#else // defined(BOOST_ASIO_HAS_STD_ARRAY)
     memcpy(bytes.elems, data_.v6.sin6_addr.s6_addr, 16);
-#endif // defined(BOOST_ASIO_HAS_STD_ARRAY)
     return boost::asio::ip::address_v6(bytes, data_.v6.sin6_scope_id);
   }
 }
 
 void endpoint::address(const boost::asio::ip::address& addr)
 {
   endpoint tmp_endpoint(addr, port());
   data_ = tmp_endpoint.data_;
 }
 
 bool operator==(const endpoint& e1, const endpoint& e2)
 {
   return e1.address() == e2.address() && e1.port() == e2.port();
 }
 
 bool operator<(const endpoint& e1, const endpoint& e2)
 {
   if (e1.address() < e2.address())
     return true;
   if (e1.address() != e2.address())
     return false;
   return e1.port() < e2.port();
 }
 
 #if !defined(BOOST_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();
 
   std::ostringstream tmp_os;
   tmp_os.imbue(std::locale::classic());
   if (is_v4())
     tmp_os << a;
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..6fde8c3 100644
--- a/3rdParty/Boost/src/boost/asio/ip/detail/socket_option.hpp
+++ b/3rdParty/Boost/src/boost/asio/ip/detail/socket_option.hpp
@@ -1,56 +1,55 @@
 //
 // detail/socket_option.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_IP_DETAIL_SOCKET_OPTION_HPP
 #define BOOST_ASIO_IP_DETAIL_SOCKET_OPTION_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 <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/ip/address.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace ip {
 namespace detail {
 namespace socket_option {
 
 // Helper template for implementing multicast enable loopback options.
 template <int IPv4_Level, int IPv4_Name, int IPv6_Level, int IPv6_Name>
 class multicast_enable_loopback
 {
 public:
 #if defined(__sun) || defined(__osf__)
   typedef unsigned char ipv4_value_type;
   typedef unsigned char ipv6_value_type;
 #elif defined(_AIX) || defined(__hpux) || defined(__QNXNTO__) 
   typedef unsigned char ipv4_value_type;
   typedef unsigned int ipv6_value_type;
 #else
   typedef int ipv4_value_type;
   typedef int ipv6_value_type;
 #endif
 
   // Default constructor.
   multicast_enable_loopback()
     : ipv4_value_(0),
       ipv6_value_(0)
   {
   }
@@ -354,124 +353,150 @@ public:
       if (s != sizeof(ipv6_value_))
       {
         std::length_error ex("multicast hops socket option resize");
         boost::throw_exception(ex);
       }
       if (ipv6_value_ < 0)
         ipv4_value_ = 0;
       else if (ipv6_value_ > 255)
         ipv4_value_ = 255;
       else
         ipv4_value_ = (ipv4_value_type)ipv6_value_;
     }
     else
     {
       if (s != sizeof(ipv4_value_))
       {
         std::length_error ex("multicast hops socket option resize");
         boost::throw_exception(ex);
       }
       ipv6_value_ = ipv4_value_;
     }
   }
 
 private:
   ipv4_value_type ipv4_value_;
   ipv6_value_type ipv6_value_;
 };
 
 // Helper template for implementing ip_mreq-based options.
 template <int IPv4_Level, int IPv4_Name, int IPv6_Level, int IPv6_Name>
 class multicast_request
 {
 public:
   // Default constructor.
   multicast_request()
-    : ipv4_value_(), // Zero-initialisation gives the "any" address.
-      ipv6_value_() // Zero-initialisation gives the "any" address.
   {
+    ipv4_value_.imr_multiaddr.s_addr =
+      boost::asio::detail::socket_ops::host_to_network_long(
+          boost::asio::ip::address_v4::any().to_ulong());
+    ipv4_value_.imr_interface.s_addr =
+      boost::asio::detail::socket_ops::host_to_network_long(
+          boost::asio::ip::address_v4::any().to_ulong());
+
+    boost::asio::detail::in6_addr_type tmp_addr = IN6ADDR_ANY_INIT;
+    ipv6_value_.ipv6mr_multiaddr = tmp_addr;
+    ipv6_value_.ipv6mr_interface = 0;
   }
 
   // Construct with multicast address only.
   explicit multicast_request(const boost::asio::ip::address& multicast_address)
-    : ipv4_value_(), // Zero-initialisation gives the "any" address.
-      ipv6_value_() // Zero-initialisation gives the "any" address.
   {
     if (multicast_address.is_v6())
     {
+      ipv4_value_.imr_multiaddr.s_addr =
+        boost::asio::detail::socket_ops::host_to_network_long(
+            boost::asio::ip::address_v4::any().to_ulong());
+      ipv4_value_.imr_interface.s_addr =
+        boost::asio::detail::socket_ops::host_to_network_long(
+            boost::asio::ip::address_v4::any().to_ulong());
+
       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);
+      memcpy(ipv6_value_.ipv6mr_multiaddr.s6_addr, bytes.elems, 16);
       ipv6_value_.ipv6mr_interface = 0;
     }
     else
     {
       ipv4_value_.imr_multiaddr.s_addr =
         boost::asio::detail::socket_ops::host_to_network_long(
             multicast_address.to_v4().to_ulong());
       ipv4_value_.imr_interface.s_addr =
         boost::asio::detail::socket_ops::host_to_network_long(
             boost::asio::ip::address_v4::any().to_ulong());
+
+      boost::asio::detail::in6_addr_type tmp_addr = IN6ADDR_ANY_INIT;
+      ipv6_value_.ipv6mr_multiaddr = tmp_addr;
+      ipv6_value_.ipv6mr_interface = 0;
     }
   }
 
   // Construct with multicast address and IPv4 address specifying an interface.
   explicit multicast_request(
       const boost::asio::ip::address_v4& multicast_address,
       const boost::asio::ip::address_v4& network_interface
         = boost::asio::ip::address_v4::any())
-    : ipv6_value_() // Zero-initialisation gives the "any" address.
   {
     ipv4_value_.imr_multiaddr.s_addr =
       boost::asio::detail::socket_ops::host_to_network_long(
           multicast_address.to_ulong());
     ipv4_value_.imr_interface.s_addr =
       boost::asio::detail::socket_ops::host_to_network_long(
           network_interface.to_ulong());
+
+    boost::asio::detail::in6_addr_type tmp_addr = IN6ADDR_ANY_INIT;
+    ipv6_value_.ipv6mr_multiaddr = tmp_addr;
+    ipv6_value_.ipv6mr_interface = 0;
   }
 
   // Construct with multicast address and IPv6 network interface index.
   explicit multicast_request(
       const boost::asio::ip::address_v6& multicast_address,
       unsigned long network_interface = 0)
-    : ipv4_value_() // Zero-initialisation gives the "any" address.
   {
+    ipv4_value_.imr_multiaddr.s_addr =
+      boost::asio::detail::socket_ops::host_to_network_long(
+          boost::asio::ip::address_v4::any().to_ulong());
+    ipv4_value_.imr_interface.s_addr =
+      boost::asio::detail::socket_ops::host_to_network_long(
+          boost::asio::ip::address_v4::any().to_ulong());
+
     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);
+    memcpy(ipv6_value_.ipv6mr_multiaddr.s6_addr, bytes.elems, 16);
     ipv6_value_.ipv6mr_interface = network_interface;
   }
 
   // Get the level of the socket option.
   template <typename Protocol>
   int level(const Protocol& protocol) const
   {
     if (protocol.family() == PF_INET6)
       return IPv6_Level;
     return IPv4_Level;
   }
 
   // Get the name of the socket option.
   template <typename Protocol>
   int name(const Protocol& protocol) const
   {
     if (protocol.family() == PF_INET6)
       return IPv6_Name;
     return IPv4_Name;
   }
 
   // Get the address of the option data.
   template <typename Protocol>
   const void* data(const Protocol& protocol) const
   {
     if (protocol.family() == PF_INET6)
       return &ipv6_value_;
     return &ipv4_value_;
   }
 
   // Get the size of the option data.
   template <typename Protocol>
   std::size_t size(const Protocol& protocol) const
   {
     if (protocol.family() == PF_INET6)
diff --git a/3rdParty/Boost/src/boost/asio/ip/host_name.hpp b/3rdParty/Boost/src/boost/asio/ip/host_name.hpp
index 9e024e1..33860c9 100644
--- a/3rdParty/Boost/src/boost/asio/ip/host_name.hpp
+++ b/3rdParty/Boost/src/boost/asio/ip/host_name.hpp
@@ -1,40 +1,40 @@
 //
 // ip/host_name.hpp
 // ~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_IP_HOST_NAME_HPP
 #define BOOST_ASIO_IP_HOST_NAME_HPP
 
 #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/system/error_code.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace ip {
 
 /// Get the current host name.
 BOOST_ASIO_DECL std::string host_name();
 
 /// Get the current host name.
 BOOST_ASIO_DECL std::string host_name(boost::system::error_code& ec);
 
 } // namespace ip
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #if defined(BOOST_ASIO_HEADER_ONLY)
diff --git a/3rdParty/Boost/src/boost/asio/ip/icmp.hpp b/3rdParty/Boost/src/boost/asio/ip/icmp.hpp
index 62748b6..14bb944 100644
--- a/3rdParty/Boost/src/boost/asio/ip/icmp.hpp
+++ b/3rdParty/Boost/src/boost/asio/ip/icmp.hpp
@@ -1,115 +1,121 @@
 //
 // ip/icmp.hpp
 // ~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_IP_ICMP_HPP
 #define BOOST_ASIO_IP_ICMP_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/socket_types.hpp>
 #include <boost/asio/basic_raw_socket.hpp>
 #include <boost/asio/ip/basic_endpoint.hpp>
 #include <boost/asio/ip/basic_resolver.hpp>
 #include <boost/asio/ip/basic_resolver_iterator.hpp>
 #include <boost/asio/ip/basic_resolver_query.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace ip {
 
 /// Encapsulates the flags needed for ICMP.
 /**
  * The boost::asio::ip::icmp class contains flags necessary for ICMP sockets.
  *
  * @par Thread Safety
  * @e Distinct @e objects: Safe.@n
  * @e Shared @e objects: Safe.
  *
  * @par Concepts:
  * Protocol, InternetProtocol.
  */
 class icmp
 {
 public:
   /// The type of a ICMP endpoint.
   typedef basic_endpoint<icmp> endpoint;
 
+  /// (Deprecated: use resolver::query.) The type of a resolver query.
+  typedef basic_resolver_query<icmp> resolver_query;
+
+  /// (Deprecated: use resolver::iterator.) The type of a resolver iterator.
+  typedef basic_resolver_iterator<icmp> resolver_iterator;
+
   /// Construct to represent the IPv4 ICMP protocol.
   static icmp v4()
   {
     return icmp(IPPROTO_ICMP, PF_INET);
   }
 
   /// Construct to represent the IPv6 ICMP protocol.
   static icmp v6()
   {
     return icmp(IPPROTO_ICMPV6, PF_INET6);
   }
 
   /// Obtain an identifier for the type of the protocol.
   int type() const
   {
     return 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_;
   }
 
   /// The ICMP socket type.
   typedef basic_raw_socket<icmp> socket;
 
   /// The ICMP resolver type.
   typedef basic_resolver<icmp> resolver;
 
   /// Compare two protocols for equality.
   friend bool operator==(const icmp& p1, const icmp& p2)
   {
     return p1.protocol_ == p2.protocol_ && p1.family_ == p2.family_;
   }
 
   /// Compare two protocols for inequality.
   friend bool operator!=(const icmp& p1, const icmp& p2)
   {
     return p1.protocol_ != p2.protocol_ || p1.family_ != p2.family_;
   }
 
 private:
   // Construct with a specific family.
-  explicit icmp(int protocol_id, int protocol_family)
-    : protocol_(protocol_id),
-      family_(protocol_family)
+  explicit icmp(int protocol, int family)
+    : protocol_(protocol),
+      family_(family)
   {
   }
 
   int protocol_;
   int family_;
 };
 
 } // namespace ip
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // BOOST_ASIO_IP_ICMP_HPP
diff --git a/3rdParty/Boost/src/boost/asio/ip/impl/address.hpp b/3rdParty/Boost/src/boost/asio/ip/impl/address.hpp
index a875e1b..94dfb17 100644
--- a/3rdParty/Boost/src/boost/asio/ip/impl/address.hpp
+++ b/3rdParty/Boost/src/boost/asio/ip/impl/address.hpp
@@ -1,40 +1,40 @@
 //
 // ip/impl/address.hpp
 // ~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_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)
 
 #include <boost/asio/detail/throw_error.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace ip {
 
 template <typename Elem, typename Traits>
 std::basic_ostream<Elem, Traits>& operator<<(
     std::basic_ostream<Elem, Traits>& os, const address& addr)
 {
   boost::system::error_code ec;
   std::string s = addr.to_string(ec);
   if (ec)
   {
     if (os.exceptions() & std::basic_ostream<Elem, Traits>::failbit)
       boost::asio::detail::throw_error(ec);
     else
       os.setstate(std::basic_ostream<Elem, Traits>::failbit);
   }
diff --git a/3rdParty/Boost/src/boost/asio/ip/impl/address.ipp b/3rdParty/Boost/src/boost/asio/ip/impl/address.ipp
index 5353758..11f06fc 100644
--- a/3rdParty/Boost/src/boost/asio/ip/impl/address.ipp
+++ b/3rdParty/Boost/src/boost/asio/ip/impl/address.ipp
@@ -1,121 +1,102 @@
 //
 // ip/impl/address.ipp
 // ~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_IP_IMPL_ADDRESS_IPP
 #define BOOST_ASIO_IP_IMPL_ADDRESS_IPP
 
 #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/error.hpp>
 #include <boost/asio/ip/address.hpp>
 #include <boost/system/system_error.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace ip {
 
 address::address()
   : type_(ipv4),
     ipv4_address_(),
     ipv6_address_()
 {
 }
 
 address::address(const boost::asio::ip::address_v4& ipv4_address)
   : type_(ipv4),
     ipv4_address_(ipv4_address),
     ipv6_address_()
 {
 }
 
 address::address(const boost::asio::ip::address_v6& ipv6_address)
   : type_(ipv6),
     ipv4_address_(),
     ipv6_address_(ipv6_address)
 {
 }
 
 address::address(const address& other)
   : type_(other.type_),
     ipv4_address_(other.ipv4_address_),
     ipv6_address_(other.ipv6_address_)
 {
 }
 
-#if defined(BOOST_ASIO_HAS_MOVE)
-address::address(address&& other)
-  : type_(other.type_),
-    ipv4_address_(other.ipv4_address_),
-    ipv6_address_(other.ipv6_address_)
-{
-}
-#endif // defined(BOOST_ASIO_HAS_MOVE)
-
 address& address::operator=(const address& other)
 {
   type_ = other.type_;
   ipv4_address_ = other.ipv4_address_;
   ipv6_address_ = other.ipv6_address_;
   return *this;
 }
 
-#if defined(BOOST_ASIO_HAS_MOVE)
-address& address::operator=(address&& other)
-{
-  type_ = other.type_;
-  ipv4_address_ = other.ipv4_address_;
-  ipv6_address_ = other.ipv6_address_;
-  return *this;
-}
-#endif // defined(BOOST_ASIO_HAS_MOVE)
-
 address& address::operator=(const boost::asio::ip::address_v4& ipv4_address)
 {
   type_ = ipv4;
   ipv4_address_ = ipv4_address;
   ipv6_address_ = boost::asio::ip::address_v6();
   return *this;
 }
 
 address& address::operator=(const boost::asio::ip::address_v6& ipv6_address)
 {
   type_ = ipv6;
   ipv4_address_ = boost::asio::ip::address_v4();
   ipv6_address_ = ipv6_address;
   return *this;
 }
 
 boost::asio::ip::address_v4 address::to_v4() const
 {
   if (type_ != ipv4)
   {
     std::bad_cast ex;
     boost::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);
   }
   return ipv6_address_;
 }
@@ -146,83 +127,62 @@ address address::from_string(const char* str, boost::system::error_code& ec)
 {
   boost::asio::ip::address_v6 ipv6_address =
     boost::asio::ip::address_v6::from_string(str, ec);
   if (!ec)
   {
     address tmp;
     tmp.type_ = ipv6;
     tmp.ipv6_address_ = ipv6_address;
     return tmp;
   }
 
   boost::asio::ip::address_v4 ipv4_address =
     boost::asio::ip::address_v4::from_string(str, ec);
   if (!ec)
   {
     address tmp;
     tmp.type_ = ipv4;
     tmp.ipv4_address_ = ipv4_address;
     return tmp;
   }
 
   return address();
 }
 
 address address::from_string(const std::string& str)
 {
   return from_string(str.c_str());
 }
 
 address address::from_string(const std::string& str,
     boost::system::error_code& ec)
 {
   return from_string(str.c_str(), ec);
 }
 
-bool address::is_loopback() const
-{
-  return (type_ == ipv4)
-    ? ipv4_address_.is_loopback()
-    : ipv6_address_.is_loopback();
-}
-
-bool address::is_unspecified() const
-{
-  return (type_ == ipv4)
-    ? ipv4_address_.is_unspecified()
-    : ipv6_address_.is_unspecified();
-}
-
-bool address::is_multicast() const
-{
-  return (type_ == ipv4)
-    ? ipv4_address_.is_multicast()
-    : ipv6_address_.is_multicast();
-}
-
 bool operator==(const address& a1, const address& a2)
 {
   if (a1.type_ != a2.type_)
     return false;
   if (a1.type_ == address::ipv6)
     return a1.ipv6_address_ == a2.ipv6_address_;
   return a1.ipv4_address_ == a2.ipv4_address_;
 }
 
 bool operator<(const address& a1, const address& a2)
 {
   if (a1.type_ < a2.type_)
     return true;
   if (a1.type_ > a2.type_)
     return false;
   if (a1.type_ == address::ipv6)
     return a1.ipv6_address_ < a2.ipv6_address_;
   return a1.ipv4_address_ < a2.ipv4_address_;
 }
 
 } // namespace ip
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // BOOST_ASIO_IP_IMPL_ADDRESS_IPP
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..d27d48d 100644
--- a/3rdParty/Boost/src/boost/asio/ip/impl/address_v4.hpp
+++ b/3rdParty/Boost/src/boost/asio/ip/impl/address_v4.hpp
@@ -1,40 +1,40 @@
 //
 // ip/impl/address_v4.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_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)
 
 #include <boost/asio/detail/throw_error.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace ip {
 
 template <typename Elem, typename Traits>
 std::basic_ostream<Elem, Traits>& operator<<(
     std::basic_ostream<Elem, Traits>& os, const address_v4& addr)
 {
   boost::system::error_code ec;
   std::string s = addr.to_string(ec);
   if (ec)
   {
     if (os.exceptions() & std::basic_ostream<Elem, Traits>::failbit)
       boost::asio::detail::throw_error(ec);
     else
       os.setstate(std::basic_ostream<Elem, Traits>::failbit);
   }
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..8bdef19 100644
--- a/3rdParty/Boost/src/boost/asio/ip/impl/address_v4.ipp
+++ b/3rdParty/Boost/src/boost/asio/ip/impl/address_v4.ipp
@@ -1,178 +1,164 @@
 //
 // ip/impl/address_v4.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_IP_IMPL_ADDRESS_V4_IPP
 #define BOOST_ASIO_IP_IMPL_ADDRESS_V4_IPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # 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/ip/address_v4.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace ip {
 
 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);
   }
 #endif // UCHAR_MAX > 0xFF
 
   using namespace std; // For memcpy.
-  memcpy(&addr_.s_addr, bytes.data(), 4);
+  memcpy(&addr_.s_addr, bytes.elems, 4);
 }
 
 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);
   }
 #endif // ULONG_MAX > 0xFFFFFFFF
 
   addr_.s_addr = boost::asio::detail::socket_ops::host_to_network_long(addr);
 }
 
 address_v4::bytes_type address_v4::to_bytes() const
 {
   using namespace std; // For memcpy.
   bytes_type bytes;
-#if defined(BOOST_ASIO_HAS_STD_ARRAY)
-  memcpy(bytes.data(), &addr_.s_addr, 4);
-#else // defined(BOOST_ASIO_HAS_STD_ARRAY)
   memcpy(bytes.elems, &addr_.s_addr, 4);
-#endif // defined(BOOST_ASIO_HAS_STD_ARRAY)
   return bytes;
 }
 
 unsigned long address_v4::to_ulong() const
 {
   return boost::asio::detail::socket_ops::network_to_host_long(addr_.s_addr);
 }
 
 std::string address_v4::to_string() const
 {
   boost::system::error_code ec;
   std::string addr = to_string(ec);
   boost::asio::detail::throw_error(ec);
   return addr;
 }
 
 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::max_addr_v4_str_len, 0, ec);
   if (addr == 0)
     return std::string();
   return addr;
 }
 
 address_v4 address_v4::from_string(const char* str)
 {
   boost::system::error_code ec;
   address_v4 addr = from_string(str, ec);
   boost::asio::detail::throw_error(ec);
   return addr;
 }
 
 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)
     return address_v4();
   return tmp;
 }
 
 address_v4 address_v4::from_string(const std::string& str)
 {
   return from_string(str.c_str());
 }
 
 address_v4 address_v4::from_string(
     const std::string& str, boost::system::error_code& ec)
 {
   return from_string(str.c_str(), ec);
 }
 
-bool address_v4::is_loopback() const
-{
-  return (to_ulong() & 0xFF000000) == 0x7F000000;
-}
-
-bool address_v4::is_unspecified() const
-{
-  return to_ulong() == 0;
-}
-
 bool address_v4::is_class_a() const
 {
-  return (to_ulong() & 0x80000000) == 0;
+  return IN_CLASSA(to_ulong());
 }
 
 bool address_v4::is_class_b() const
 {
-  return (to_ulong() & 0xC0000000) == 0x80000000;
+  return IN_CLASSB(to_ulong());
 }
 
 bool address_v4::is_class_c() const
 {
-  return (to_ulong() & 0xE0000000) == 0xC0000000;
+  return IN_CLASSC(to_ulong());
 }
 
 bool address_v4::is_multicast() const
 {
-  return (to_ulong() & 0xF0000000) == 0xE0000000;
+  return IN_MULTICAST(to_ulong());
 }
 
 address_v4 address_v4::broadcast(const address_v4& addr, const address_v4& mask)
 {
   return address_v4(addr.to_ulong() | (mask.to_ulong() ^ 0xFFFFFFFF));
 }
 
 address_v4 address_v4::netmask(const address_v4& addr)
 {
   if (addr.is_class_a())
     return address_v4(0xFF000000);
   if (addr.is_class_b())
     return address_v4(0xFFFF0000);
   if (addr.is_class_c())
     return address_v4(0xFFFFFF00);
   return address_v4(0xFFFFFFFF);
 }
 
 } // namespace ip
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // BOOST_ASIO_IP_IMPL_ADDRESS_V4_IPP
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..11e1797 100644
--- a/3rdParty/Boost/src/boost/asio/ip/impl/address_v6.hpp
+++ b/3rdParty/Boost/src/boost/asio/ip/impl/address_v6.hpp
@@ -1,40 +1,40 @@
 //
 // ip/impl/address_v6.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_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)
 
 #include <boost/asio/detail/throw_error.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace ip {
 
 template <typename Elem, typename Traits>
 std::basic_ostream<Elem, Traits>& operator<<(
     std::basic_ostream<Elem, Traits>& os, const address_v6& addr)
 {
   boost::system::error_code ec;
   std::string s = addr.to_string(ec);
   if (ec)
   {
     if (os.exceptions() & std::basic_ostream<Elem, Traits>::failbit)
       boost::asio::detail::throw_error(ec);
     else
       os.setstate(std::basic_ostream<Elem, Traits>::failbit);
   }
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..5a3dddd 100644
--- a/3rdParty/Boost/src/boost/asio/ip/impl/address_v6.ipp
+++ b/3rdParty/Boost/src/boost/asio/ip/impl/address_v6.ipp
@@ -1,299 +1,286 @@
 //
 // ip/impl/address_v6.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_IP_IMPL_ADDRESS_V6_IPP
 #define BOOST_ASIO_IP_IMPL_ADDRESS_V6_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 <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/error.hpp>
 #include <boost/asio/ip/address_v6.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace ip {
 
 address_v6::address_v6()
-  : addr_(),
-    scope_id_(0)
+  : scope_id_(0)
 {
+  boost::asio::detail::in6_addr_type tmp_addr = IN6ADDR_ANY_INIT;
+  addr_ = tmp_addr;
 }
 
 address_v6::address_v6(const address_v6::bytes_type& bytes,
-    unsigned long scope)
-  : scope_id_(scope)
+    unsigned long scope_id)
+  : scope_id_(scope_id)
 {
 #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);
     }
   }
 #endif // UCHAR_MAX > 0xFF
 
   using namespace std; // For memcpy.
-  memcpy(addr_.s6_addr, bytes.data(), 16);
+  memcpy(addr_.s6_addr, bytes.elems, 16);
 }
 
 address_v6::address_v6(const address_v6& other)
   : addr_(other.addr_),
     scope_id_(other.scope_id_)
 {
 }
 
-#if defined(BOOST_ASIO_HAS_MOVE)
-address_v6::address_v6(address_v6&& other)
-  : addr_(other.addr_),
-    scope_id_(other.scope_id_)
-{
-}
-#endif // defined(BOOST_ASIO_HAS_MOVE)
-
 address_v6& address_v6::operator=(const address_v6& other)
 {
   addr_ = other.addr_;
   scope_id_ = other.scope_id_;
   return *this;
 }
 
-#if defined(BOOST_ASIO_HAS_MOVE)
-address_v6& address_v6::operator=(address_v6&& other)
-{
-  addr_ = other.addr_;
-  scope_id_ = other.scope_id_;
-  return *this;
-}
-#endif // defined(BOOST_ASIO_HAS_MOVE)
-
 address_v6::bytes_type address_v6::to_bytes() const
 {
   using namespace std; // For memcpy.
   bytes_type bytes;
-#if defined(BOOST_ASIO_HAS_STD_ARRAY)
-  memcpy(bytes.data(), addr_.s6_addr, 16);
-#else // defined(BOOST_ASIO_HAS_STD_ARRAY)
   memcpy(bytes.elems, addr_.s6_addr, 16);
-#endif // defined(BOOST_ASIO_HAS_STD_ARRAY)
   return bytes;
 }
 
 std::string address_v6::to_string() const
 {
   boost::system::error_code ec;
   std::string addr = to_string(ec);
   boost::asio::detail::throw_error(ec);
   return addr;
 }
 
 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::max_addr_v6_str_len, scope_id_, ec);
   if (addr == 0)
     return std::string();
   return addr;
 }
 
 address_v6 address_v6::from_string(const char* str)
 {
   boost::system::error_code ec;
   address_v6 addr = from_string(str, ec);
   boost::asio::detail::throw_error(ec);
   return addr;
 }
 
 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)
     return address_v6();
   return tmp;
 }
 
 address_v6 address_v6::from_string(const std::string& str)
 {
   return from_string(str.c_str());
 }
 
 address_v6 address_v6::from_string(
     const std::string& str, boost::system::error_code& ec)
 {
   return from_string(str.c_str(), ec);
 }
 
 address_v4 address_v6::to_v4() const
 {
   if (!is_v4_mapped() && !is_v4_compatible())
   {
     std::bad_cast ex;
     boost::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);
 }
 
 bool address_v6::is_loopback() const
 {
+#if defined(__BORLANDC__)
   return ((addr_.s6_addr[0] == 0) && (addr_.s6_addr[1] == 0)
       && (addr_.s6_addr[2] == 0) && (addr_.s6_addr[3] == 0)
       && (addr_.s6_addr[4] == 0) && (addr_.s6_addr[5] == 0)
       && (addr_.s6_addr[6] == 0) && (addr_.s6_addr[7] == 0)
       && (addr_.s6_addr[8] == 0) && (addr_.s6_addr[9] == 0)
       && (addr_.s6_addr[10] == 0) && (addr_.s6_addr[11] == 0)
       && (addr_.s6_addr[12] == 0) && (addr_.s6_addr[13] == 0)
       && (addr_.s6_addr[14] == 0) && (addr_.s6_addr[15] == 1));
+#else
+  using namespace boost::asio::detail;
+  return IN6_IS_ADDR_LOOPBACK(&addr_) != 0;
+#endif
 }
 
 bool address_v6::is_unspecified() const
 {
+#if defined(__BORLANDC__)
   return ((addr_.s6_addr[0] == 0) && (addr_.s6_addr[1] == 0)
       && (addr_.s6_addr[2] == 0) && (addr_.s6_addr[3] == 0)
       && (addr_.s6_addr[4] == 0) && (addr_.s6_addr[5] == 0)
       && (addr_.s6_addr[6] == 0) && (addr_.s6_addr[7] == 0)
       && (addr_.s6_addr[8] == 0) && (addr_.s6_addr[9] == 0)
       && (addr_.s6_addr[10] == 0) && (addr_.s6_addr[11] == 0)
       && (addr_.s6_addr[12] == 0) && (addr_.s6_addr[13] == 0)
       && (addr_.s6_addr[14] == 0) && (addr_.s6_addr[15] == 0));
+#else
+  using namespace boost::asio::detail;
+  return IN6_IS_ADDR_UNSPECIFIED(&addr_) != 0;
+#endif
 }
 
 bool address_v6::is_link_local() const
 {
-  return ((addr_.s6_addr[0] == 0xfe) && ((addr_.s6_addr[1] & 0xc0) == 0x80));
+  using namespace boost::asio::detail;
+  return IN6_IS_ADDR_LINKLOCAL(&addr_) != 0;
 }
 
 bool address_v6::is_site_local() const
 {
-  return ((addr_.s6_addr[0] == 0xfe) && ((addr_.s6_addr[1] & 0xc0) == 0xc0));
+  using namespace boost::asio::detail;
+  return IN6_IS_ADDR_SITELOCAL(&addr_) != 0;
 }
 
 bool address_v6::is_v4_mapped() const
 {
-  return ((addr_.s6_addr[0] == 0) && (addr_.s6_addr[1] == 0)
-      && (addr_.s6_addr[2] == 0) && (addr_.s6_addr[3] == 0)
-      && (addr_.s6_addr[4] == 0) && (addr_.s6_addr[5] == 0)
-      && (addr_.s6_addr[6] == 0) && (addr_.s6_addr[7] == 0)
-      && (addr_.s6_addr[8] == 0) && (addr_.s6_addr[9] == 0)
-      && (addr_.s6_addr[10] == 0xff) && (addr_.s6_addr[11] == 0xff));
+  using namespace boost::asio::detail;
+  return IN6_IS_ADDR_V4MAPPED(&addr_) != 0;
 }
 
 bool address_v6::is_v4_compatible() const
 {
-  return ((addr_.s6_addr[0] == 0) && (addr_.s6_addr[1] == 0)
-      && (addr_.s6_addr[2] == 0) && (addr_.s6_addr[3] == 0)
-      && (addr_.s6_addr[4] == 0) && (addr_.s6_addr[5] == 0)
-      && (addr_.s6_addr[6] == 0) && (addr_.s6_addr[7] == 0)
-      && (addr_.s6_addr[8] == 0) && (addr_.s6_addr[9] == 0)
-      && (addr_.s6_addr[10] == 0) && (addr_.s6_addr[11] == 0)
-      && !((addr_.s6_addr[12] == 0)
-        && (addr_.s6_addr[13] == 0)
-        && (addr_.s6_addr[14] == 0)
-        && ((addr_.s6_addr[15] == 0) || (addr_.s6_addr[15] == 1))));
+  using namespace boost::asio::detail;
+  return IN6_IS_ADDR_V4COMPAT(&addr_) != 0;
 }
 
 bool address_v6::is_multicast() const
 {
-  return (addr_.s6_addr[0] == 0xff);
+  using namespace boost::asio::detail;
+  return IN6_IS_ADDR_MULTICAST(&addr_) != 0;
 }
 
 bool address_v6::is_multicast_global() const
 {
-  return ((addr_.s6_addr[0] == 0xff) && ((addr_.s6_addr[1] & 0x0f) == 0x0e));
+  using namespace boost::asio::detail;
+  return IN6_IS_ADDR_MC_GLOBAL(&addr_) != 0;
 }
 
 bool address_v6::is_multicast_link_local() const
 {
-  return ((addr_.s6_addr[0] == 0xff) && ((addr_.s6_addr[1] & 0x0f) == 0x02));
+  using namespace boost::asio::detail;
+  return IN6_IS_ADDR_MC_LINKLOCAL(&addr_) != 0;
 }
 
 bool address_v6::is_multicast_node_local() const
 {
-  return ((addr_.s6_addr[0] == 0xff) && ((addr_.s6_addr[1] & 0x0f) == 0x01));
+  using namespace boost::asio::detail;
+  return IN6_IS_ADDR_MC_NODELOCAL(&addr_) != 0;
 }
 
 bool address_v6::is_multicast_org_local() const
 {
-  return ((addr_.s6_addr[0] == 0xff) && ((addr_.s6_addr[1] & 0x0f) == 0x08));
+  using namespace boost::asio::detail;
+  return IN6_IS_ADDR_MC_ORGLOCAL(&addr_) != 0;
 }
 
 bool address_v6::is_multicast_site_local() const
 {
-  return ((addr_.s6_addr[0] == 0xff) && ((addr_.s6_addr[1] & 0x0f) == 0x05));
+  using namespace boost::asio::detail;
+  return IN6_IS_ADDR_MC_SITELOCAL(&addr_) != 0;
 }
 
 bool operator==(const address_v6& a1, const address_v6& a2)
 {
   using namespace std; // For memcmp.
   return memcmp(&a1.addr_, &a2.addr_,
       sizeof(boost::asio::detail::in6_addr_type)) == 0
     && a1.scope_id_ == a2.scope_id_;
 }
 
 bool operator<(const address_v6& a1, const address_v6& a2)
 {
   using namespace std; // For memcmp.
   int memcmp_result = memcmp(&a1.addr_, &a2.addr_,
       sizeof(boost::asio::detail::in6_addr_type));
   if (memcmp_result < 0)
     return true;
   if (memcmp_result > 0)
     return false;
   return a1.scope_id_ < a2.scope_id_;
 }
 
 address_v6 address_v6::loopback()
 {
   address_v6 tmp;
-  tmp.addr_.s6_addr[15] = 1;
+  boost::asio::detail::in6_addr_type tmp_addr = IN6ADDR_LOOPBACK_INIT;
+  tmp.addr_ = tmp_addr;
   return tmp;
 }
 
 address_v6 address_v6::v4_mapped(const address_v4& addr)
 {
   address_v4::bytes_type v4_bytes = addr.to_bytes();
   bytes_type v6_bytes = { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF,
     v4_bytes[0], v4_bytes[1], v4_bytes[2], v4_bytes[3] } };
   return address_v6(v6_bytes);
 }
 
 address_v6 address_v6::v4_compatible(const address_v4& addr)
 {
   address_v4::bytes_type v4_bytes = addr.to_bytes();
   bytes_type v6_bytes = { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     v4_bytes[0], v4_bytes[1], v4_bytes[2], v4_bytes[3] } };
   return address_v6(v6_bytes);
 }
 
 } // namespace ip
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // BOOST_ASIO_IP_IMPL_ADDRESS_V6_IPP
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..9d39c87 100644
--- a/3rdParty/Boost/src/boost/asio/ip/impl/basic_endpoint.hpp
+++ b/3rdParty/Boost/src/boost/asio/ip/impl/basic_endpoint.hpp
@@ -1,40 +1,40 @@
 //
 // ip/impl/basic_endpoint.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_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)
 
 #include <boost/asio/detail/throw_error.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace ip {
 
 template <typename Elem, typename Traits, typename InternetProtocol>
 std::basic_ostream<Elem, Traits>& operator<<(
     std::basic_ostream<Elem, Traits>& os,
     const basic_endpoint<InternetProtocol>& endpoint)
 {
   boost::asio::ip::detail::endpoint tmp_ep(endpoint.address(), endpoint.port());
   boost::system::error_code ec;
   std::string s = tmp_ep.to_string(ec);
   if (ec)
   {
     if (os.exceptions() & std::basic_ostream<Elem, Traits>::failbit)
       boost::asio::detail::throw_error(ec);
     else
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..734341e 100644
--- a/3rdParty/Boost/src/boost/asio/ip/impl/host_name.ipp
+++ b/3rdParty/Boost/src/boost/asio/ip/impl/host_name.ipp
@@ -1,40 +1,40 @@
 //
 // ip/impl/host_name.ipp
 // ~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_IP_IMPL_HOST_NAME_IPP
 #define BOOST_ASIO_IP_IMPL_HOST_NAME_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/socket_ops.hpp>
 #include <boost/asio/detail/throw_error.hpp>
 #include <boost/asio/detail/winsock_init.hpp>
 #include <boost/asio/ip/host_name.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace ip {
 
 std::string host_name()
 {
   char name[1024];
   boost::system::error_code ec;
   if (boost::asio::detail::socket_ops::gethostname(name, sizeof(name), ec) != 0)
   {
     boost::asio::detail::throw_error(ec);
     return std::string();
   }
   return std::string(name);
 }
diff --git a/3rdParty/Boost/src/boost/asio/ip/multicast.hpp b/3rdParty/Boost/src/boost/asio/ip/multicast.hpp
index a0a3c41..2a02627 100644
--- a/3rdParty/Boost/src/boost/asio/ip/multicast.hpp
+++ b/3rdParty/Boost/src/boost/asio/ip/multicast.hpp
@@ -1,40 +1,40 @@
 //
 // ip/multicast.hpp
 // ~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_IP_MULTICAST_HPP
 #define BOOST_ASIO_IP_MULTICAST_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/ip/detail/socket_option.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace ip {
 namespace multicast {
 
 /// Socket option to join a multicast group on a specified interface.
 /**
  * Implements the IPPROTO_IP/IP_ADD_MEMBERSHIP socket option.
  *
  * @par Examples
  * Setting the option to join a multicast group:
  * @code
  * boost::asio::ip::udp::socket socket(io_service); 
  * ...
  * boost::asio::ip::address multicast_address =
  *   boost::asio::ip::address::from_string("225.0.0.1");
  * boost::asio::ip::multicast::join_group option(multicast_address);
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..96ad512 100644
--- a/3rdParty/Boost/src/boost/asio/ip/resolver_query_base.hpp
+++ b/3rdParty/Boost/src/boost/asio/ip/resolver_query_base.hpp
@@ -1,40 +1,40 @@
 //
 // ip/resolver_query_base.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_IP_RESOLVER_QUERY_BASE_HPP
 #define BOOST_ASIO_IP_RESOLVER_QUERY_BASE_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/detail/workaround.hpp>
 #include <boost/asio/detail/socket_types.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace ip {
 
 /// The resolver_query_base class is used as a base for the
 /// basic_resolver_query class templates to provide a common place to define
 /// the flag constants.
 class resolver_query_base
 {
 public:
 #if defined(GENERATING_DOCUMENTATION)
   /// A bitmask type (C++ Std [lib.bitmask.types]).
   typedef unspecified flags;
 
   /// Determine the canonical name of the host specified in the query.
   static const flags canonical_name = implementation_defined;
 
diff --git a/3rdParty/Boost/src/boost/asio/ip/resolver_service.hpp b/3rdParty/Boost/src/boost/asio/ip/resolver_service.hpp
index 74915d2..db0554b 100644
--- a/3rdParty/Boost/src/boost/asio/ip/resolver_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/ip/resolver_service.hpp
@@ -1,40 +1,40 @@
 //
 // ip/resolver_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_IP_RESOLVER_SERVICE_HPP
 #define BOOST_ASIO_IP_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>
 #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>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace ip {
 
 /// Default service implementation for a resolver.
 template <typename InternetProtocol>
 class resolver_service
 #if defined(GENERATING_DOCUMENTATION)
   : public boost::asio::io_service::service
 #else
   : public boost::asio::detail::service_base<
       resolver_service<InternetProtocol> >
 #endif
 {
@@ -45,109 +45,101 @@ public:
 #endif
 
   /// The protocol type.
   typedef InternetProtocol protocol_type;
 
   /// The endpoint type.
   typedef typename InternetProtocol::endpoint endpoint_type;
 
   /// The query type.
   typedef basic_resolver_query<InternetProtocol> query_type;
 
   /// The iterator type.
   typedef basic_resolver_iterator<InternetProtocol> iterator_type;
 
 private:
   // The type of the platform-specific implementation.
   typedef boost::asio::detail::resolver_service<InternetProtocol>
     service_impl_type;
 
 public:
   /// The type of a resolver implementation.
 #if defined(GENERATING_DOCUMENTATION)
   typedef implementation_defined implementation_type;
 #else
   typedef typename service_impl_type::implementation_type implementation_type;
 #endif
 
   /// Construct a new resolver service for the specified io_service.
   explicit resolver_service(boost::asio::io_service& io_service)
     : boost::asio::detail::service_base<
         resolver_service<InternetProtocol> >(io_service),
       service_impl_(io_service)
   {
   }
 
+  /// Destroy all user-defined handler objects owned by the service.
+  void shutdown_service()
+  {
+    service_impl_.shutdown_service();
+  }
+
   /// Construct a new resolver implementation.
   void construct(implementation_type& impl)
   {
     service_impl_.construct(impl);
   }
 
   /// Destroy a resolver implementation.
   void destroy(implementation_type& impl)
   {
     service_impl_.destroy(impl);
   }
 
   /// Cancel pending asynchronous operations.
   void cancel(implementation_type& impl)
   {
     service_impl_.cancel(impl);
   }
 
   /// Resolve a query to a list of entries.
   iterator_type resolve(implementation_type& impl, const query_type& query,
       boost::system::error_code& ec)
   {
     return service_impl_.resolve(impl, query, ec);
   }
 
   /// Asynchronously resolve a query to a list of entries.
-  template <typename ResolveHandler>
+  template <typename Handler>
   void async_resolve(implementation_type& impl, const query_type& query,
-      BOOST_ASIO_MOVE_ARG(ResolveHandler) handler)
+      Handler handler)
   {
-    service_impl_.async_resolve(impl, query,
-        BOOST_ASIO_MOVE_CAST(ResolveHandler)(handler));
+    service_impl_.async_resolve(impl, query, handler);
   }
 
   /// 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_MOVE_ARG(ResolveHandler) handler)
+      ResolveHandler handler)
   {
-    return service_impl_.async_resolve(impl, endpoint,
-        BOOST_ASIO_MOVE_CAST(ResolveHandler)(handler));
+    return service_impl_.async_resolve(impl, endpoint, handler);
   }
 
 private:
-  // Destroy all user-defined handler objects owned by the service.
-  void shutdown_service()
-  {
-    service_impl_.shutdown_service();
-  }
-
-  // Perform any fork-related housekeeping.
-  void fork_service(boost::asio::io_service::fork_event event)
-  {
-    service_impl_.fork_service(event);
-  }
-
   // The platform-specific implementation.
   service_impl_type service_impl_;
 };
 
 } // namespace ip
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // BOOST_ASIO_IP_RESOLVER_SERVICE_HPP
diff --git a/3rdParty/Boost/src/boost/asio/ip/tcp.hpp b/3rdParty/Boost/src/boost/asio/ip/tcp.hpp
index 0256e6f..4163a8d 100644
--- a/3rdParty/Boost/src/boost/asio/ip/tcp.hpp
+++ b/3rdParty/Boost/src/boost/asio/ip/tcp.hpp
@@ -1,86 +1,92 @@
 //
 // ip/tcp.hpp
 // ~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_IP_TCP_HPP
 #define BOOST_ASIO_IP_TCP_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/basic_socket_acceptor.hpp>
 #include <boost/asio/basic_socket_iostream.hpp>
 #include <boost/asio/basic_stream_socket.hpp>
 #include <boost/asio/detail/socket_option.hpp>
 #include <boost/asio/detail/socket_types.hpp>
 #include <boost/asio/ip/basic_endpoint.hpp>
 #include <boost/asio/ip/basic_resolver.hpp>
 #include <boost/asio/ip/basic_resolver_iterator.hpp>
 #include <boost/asio/ip/basic_resolver_query.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace ip {
 
 /// Encapsulates the flags needed for TCP.
 /**
  * The boost::asio::ip::tcp class contains flags necessary for TCP sockets.
  *
  * @par Thread Safety
  * @e Distinct @e objects: Safe.@n
  * @e Shared @e objects: Safe.
  *
  * @par Concepts:
  * Protocol, InternetProtocol.
  */
 class tcp
 {
 public:
   /// The type of a TCP endpoint.
   typedef basic_endpoint<tcp> endpoint;
 
+  /// (Deprecated: use resolver::query.) The type of a resolver query.
+  typedef basic_resolver_query<tcp> resolver_query;
+
+  /// (Deprecated: use resolver::iterator.) The type of a resolver iterator.
+  typedef basic_resolver_iterator<tcp> resolver_iterator;
+
   /// Construct to represent the IPv4 TCP protocol.
   static tcp v4()
   {
     return tcp(PF_INET);
   }
 
   /// Construct to represent the IPv6 TCP protocol.
   static tcp v6()
   {
     return tcp(PF_INET6);
   }
 
   /// Obtain an identifier for the type of the protocol.
   int type() const
   {
     return SOCK_STREAM;
   }
 
   /// Obtain an identifier for the protocol.
   int protocol() const
   {
     return IPPROTO_TCP;
   }
 
   /// Obtain an identifier for the protocol family.
   int family() const
   {
     return family_;
   }
 
   /// The TCP socket type.
   typedef basic_stream_socket<tcp> socket;
 
   /// The TCP acceptor type.
   typedef basic_socket_acceptor<tcp> acceptor;
@@ -108,50 +114,50 @@ public:
    *
    * @par
    * Getting the current option value:
    * @code
    * boost::asio::ip::tcp::socket socket(io_service); 
    * ...
    * boost::asio::ip::tcp::no_delay option;
    * socket.get_option(option);
    * bool is_set = option.value();
    * @endcode
    *
    * @par Concepts:
    * 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;
 #endif
 
   /// Compare two protocols for equality.
   friend bool operator==(const tcp& p1, const tcp& p2)
   {
     return p1.family_ == p2.family_;
   }
 
   /// Compare two protocols for inequality.
   friend bool operator!=(const tcp& p1, const tcp& p2)
   {
     return p1.family_ != p2.family_;
   }
 
 private:
   // Construct with a specific family.
-  explicit tcp(int protocol_family)
-    : family_(protocol_family)
+  explicit tcp(int family)
+    : family_(family)
   {
   }
 
   int family_;
 };
 
 } // namespace ip
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // BOOST_ASIO_IP_TCP_HPP
diff --git a/3rdParty/Boost/src/boost/asio/ip/udp.hpp b/3rdParty/Boost/src/boost/asio/ip/udp.hpp
index acf61ef..40f5d3a 100644
--- a/3rdParty/Boost/src/boost/asio/ip/udp.hpp
+++ b/3rdParty/Boost/src/boost/asio/ip/udp.hpp
@@ -1,113 +1,119 @@
 //
 // ip/udp.hpp
 // ~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_IP_UDP_HPP
 #define BOOST_ASIO_IP_UDP_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/basic_datagram_socket.hpp>
 #include <boost/asio/detail/socket_types.hpp>
 #include <boost/asio/ip/basic_endpoint.hpp>
 #include <boost/asio/ip/basic_resolver.hpp>
 #include <boost/asio/ip/basic_resolver_iterator.hpp>
 #include <boost/asio/ip/basic_resolver_query.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace ip {
 
 /// Encapsulates the flags needed for UDP.
 /**
  * The boost::asio::ip::udp class contains flags necessary for UDP sockets.
  *
  * @par Thread Safety
  * @e Distinct @e objects: Safe.@n
  * @e Shared @e objects: Safe.
  *
  * @par Concepts:
  * Protocol, InternetProtocol.
  */
 class udp
 {
 public:
   /// The type of a UDP endpoint.
   typedef basic_endpoint<udp> endpoint;
 
+  /// (Deprecated: use resolver::query.) The type of a resolver query.
+  typedef basic_resolver_query<udp> resolver_query;
+
+  /// (Deprecated: use resolver::iterator.) The type of a resolver iterator.
+  typedef basic_resolver_iterator<udp> resolver_iterator;
+
   /// Construct to represent the IPv4 UDP protocol.
   static udp v4()
   {
     return udp(PF_INET);
   }
 
   /// Construct to represent the IPv6 UDP protocol.
   static udp v6()
   {
     return udp(PF_INET6);
   }
 
   /// Obtain an identifier for the type of the protocol.
   int type() const
   {
     return SOCK_DGRAM;
   }
 
   /// Obtain an identifier for the protocol.
   int protocol() const
   {
     return IPPROTO_UDP;
   }
 
   /// Obtain an identifier for the protocol family.
   int family() const
   {
     return family_;
   }
 
   /// The UDP socket type.
   typedef basic_datagram_socket<udp> socket;
 
   /// The UDP resolver type.
   typedef basic_resolver<udp> resolver;
 
   /// Compare two protocols for equality.
   friend bool operator==(const udp& p1, const udp& p2)
   {
     return p1.family_ == p2.family_;
   }
 
   /// Compare two protocols for inequality.
   friend bool operator!=(const udp& p1, const udp& p2)
   {
     return p1.family_ != p2.family_;
   }
 
 private:
   // Construct with a specific family.
-  explicit udp(int protocol_family)
-    : family_(protocol_family)
+  explicit udp(int family)
+    : family_(family)
   {
   }
 
   int family_;
 };
 
 } // namespace ip
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // BOOST_ASIO_IP_UDP_HPP
diff --git a/3rdParty/Boost/src/boost/asio/ip/unicast.hpp b/3rdParty/Boost/src/boost/asio/ip/unicast.hpp
index 5ff0dc8..dc7d8e9 100644
--- a/3rdParty/Boost/src/boost/asio/ip/unicast.hpp
+++ b/3rdParty/Boost/src/boost/asio/ip/unicast.hpp
@@ -1,40 +1,40 @@
 //
 // ip/unicast.hpp
 // ~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_IP_UNICAST_HPP
 #define BOOST_ASIO_IP_UNICAST_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/ip/detail/socket_option.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace ip {
 namespace unicast {
 
 /// Socket option for time-to-live associated with outgoing unicast packets.
 /**
  * Implements the IPPROTO_IP/IP_UNICAST_TTL socket option.
  *
  * @par Examples
  * Setting the option:
  * @code
  * boost::asio::ip::udp::socket socket(io_service); 
  * ...
  * boost::asio::ip::unicast::hops option(4);
  * socket.set_option(option);
  * @endcode
diff --git a/3rdParty/Boost/src/boost/asio/ip/v6_only.hpp b/3rdParty/Boost/src/boost/asio/ip/v6_only.hpp
index 0441991..e67a548 100644
--- a/3rdParty/Boost/src/boost/asio/ip/v6_only.hpp
+++ b/3rdParty/Boost/src/boost/asio/ip/v6_only.hpp
@@ -1,40 +1,40 @@
 //
 // ip/v6_only.hpp
 // ~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_IP_V6_ONLY_HPP
 #define BOOST_ASIO_IP_V6_ONLY_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/socket_option.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace ip {
 
 /// Socket option for determining whether an IPv6 socket supports IPv6
 /// communication only.
 /**
  * Implements the IPPROTO_IPV6/IP_V6ONLY socket option.
  *
  * @par Examples
  * Setting the option:
  * @code
  * boost::asio::ip::tcp::socket socket(io_service); 
  * ...
  * boost::asio::ip::v6_only option(true);
  * socket.set_option(option);
  * @endcode
  *
diff --git a/3rdParty/Boost/src/boost/asio/is_read_buffered.hpp b/3rdParty/Boost/src/boost/asio/is_read_buffered.hpp
index 8ad32e4..1aac50f 100644
--- a/3rdParty/Boost/src/boost/asio/is_read_buffered.hpp
+++ b/3rdParty/Boost/src/boost/asio/is_read_buffered.hpp
@@ -1,40 +1,40 @@
 //
 // is_read_buffered.hpp
 // ~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_IS_READ_BUFFERED_HPP
 #define BOOST_ASIO_IS_READ_BUFFERED_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/buffered_read_stream_fwd.hpp>
 #include <boost/asio/buffered_stream_fwd.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 
 namespace detail {
 
 template <typename Stream>
 char is_read_buffered_helper(buffered_stream<Stream>* s);
 
 template <typename Stream>
 char is_read_buffered_helper(buffered_read_stream<Stream>* s);
 
 struct is_read_buffered_big_type { char data[10]; };
 is_read_buffered_big_type is_read_buffered_helper(...);
 
 } // namespace detail
 
 /// The is_read_buffered class is a traits class that may be used to determine
diff --git a/3rdParty/Boost/src/boost/asio/is_write_buffered.hpp b/3rdParty/Boost/src/boost/asio/is_write_buffered.hpp
index bbc2e22..03de0f1 100644
--- a/3rdParty/Boost/src/boost/asio/is_write_buffered.hpp
+++ b/3rdParty/Boost/src/boost/asio/is_write_buffered.hpp
@@ -1,40 +1,40 @@
 //
 // is_write_buffered.hpp
 // ~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_IS_WRITE_BUFFERED_HPP
 #define BOOST_ASIO_IS_WRITE_BUFFERED_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/buffered_stream_fwd.hpp>
 #include <boost/asio/buffered_write_stream_fwd.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 
 namespace detail {
 
 template <typename Stream>
 char is_write_buffered_helper(buffered_stream<Stream>* s);
 
 template <typename Stream>
 char is_write_buffered_helper(buffered_write_stream<Stream>* s);
 
 struct is_write_buffered_big_type { char data[10]; };
 is_write_buffered_big_type is_write_buffered_helper(...);
 
 } // namespace detail
 
 /// The is_write_buffered class is a traits class that may be used to determine
diff --git a/3rdParty/Boost/src/boost/asio/local/basic_endpoint.hpp b/3rdParty/Boost/src/boost/asio/local/basic_endpoint.hpp
index f191dd6..fcb53a0 100644
--- a/3rdParty/Boost/src/boost/asio/local/basic_endpoint.hpp
+++ b/3rdParty/Boost/src/boost/asio/local/basic_endpoint.hpp
@@ -1,172 +1,155 @@
 //
 // local/basic_endpoint.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2011 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)
 //
 
 #ifndef BOOST_ASIO_LOCAL_BASIC_ENDPOINT_HPP
 #define BOOST_ASIO_LOCAL_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>
 
 #if defined(BOOST_ASIO_HAS_LOCAL_SOCKETS) \
   || defined(GENERATING_DOCUMENTATION)
 
 #include <boost/asio/local/detail/endpoint.hpp>
 
 #if !defined(BOOST_NO_IOSTREAM)
 # include <iosfwd>
 #endif // !defined(BOOST_NO_IOSTREAM)
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace local {
 
 /// Describes an endpoint for a UNIX socket.
 /**
  * The boost::asio::local::basic_endpoint class template describes an endpoint
  * that may be associated with a particular UNIX socket.
  *
  * @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 using the specified path name.
-  basic_endpoint(const char* path_name)
-    : impl_(path_name)
+  basic_endpoint(const char* path)
+    : impl_(path)
   {
   }
 
   /// Construct an endpoint using the specified path name.
-  basic_endpoint(const std::string& path_name)
-    : impl_(path_name)
+  basic_endpoint(const std::string& path)
+    : impl_(path)
   {
   }
 
   /// 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();
   }
 
   /// 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)
+  void resize(std::size_t size)
   {
-    impl_.resize(new_size);
+    impl_.resize(size);
   }
 
   /// Get the capacity of the endpoint in the native type.
   std::size_t capacity() const
   {
     return impl_.capacity();
   }
 
   /// Get the path associated with the endpoint.
   std::string path() const
   {
     return impl_.path();
   }
 
   /// Set the path associated with the endpoint.
   void path(const char* p)
   {
     impl_.path(p);
   }
 
   /// Set the path associated with the endpoint.
   void path(const std::string& p)
   {
     impl_.path(p);
   }
 
   /// 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,
diff --git a/3rdParty/Boost/src/boost/asio/local/connect_pair.hpp b/3rdParty/Boost/src/boost/asio/local/connect_pair.hpp
index e691398..9ef6cd3 100644
--- a/3rdParty/Boost/src/boost/asio/local/connect_pair.hpp
+++ b/3rdParty/Boost/src/boost/asio/local/connect_pair.hpp
@@ -1,90 +1,90 @@
 //
 // local/connect_pair.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_LOCAL_CONNECT_PAIR_HPP
 #define BOOST_ASIO_LOCAL_CONNECT_PAIR_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_LOCAL_SOCKETS) \
   || defined(GENERATING_DOCUMENTATION)
 
 #include <boost/asio/basic_socket.hpp>
 #include <boost/asio/detail/socket_ops.hpp>
 #include <boost/asio/detail/throw_error.hpp>
 #include <boost/asio/error.hpp>
 #include <boost/asio/local/basic_endpoint.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace local {
 
 /// Create a pair of connected sockets.
 template <typename Protocol, typename SocketService1, typename SocketService2>
 void connect_pair(
     basic_socket<Protocol, SocketService1>& socket1,
     basic_socket<Protocol, SocketService2>& socket2);
 
 /// Create a pair of connected sockets.
 template <typename Protocol, typename SocketService1, typename SocketService2>
 boost::system::error_code connect_pair(
     basic_socket<Protocol, SocketService1>& socket1,
     basic_socket<Protocol, SocketService2>& socket2,
     boost::system::error_code& ec);
 
 template <typename Protocol, typename SocketService1, typename SocketService2>
 inline void connect_pair(
     basic_socket<Protocol, SocketService1>& socket1,
     basic_socket<Protocol, SocketService2>& socket2)
 {
   boost::system::error_code ec;
   connect_pair(socket1, socket2, ec);
-  boost::asio::detail::throw_error(ec, "connect_pair");
+  boost::asio::detail::throw_error(ec);
 }
 
 template <typename Protocol, typename SocketService1, typename SocketService2>
 inline boost::system::error_code connect_pair(
     basic_socket<Protocol, SocketService1>& socket1,
     basic_socket<Protocol, SocketService2>& socket2,
     boost::system::error_code& ec)
 {
   // Check that this function is only being used with a UNIX domain socket.
   boost::asio::local::basic_endpoint<Protocol>* tmp
     = static_cast<typename Protocol::endpoint*>(0);
   (void)tmp;
 
   Protocol protocol;
   boost::asio::detail::socket_type sv[2];
   if (boost::asio::detail::socket_ops::socketpair(protocol.family(),
         protocol.type(), protocol.protocol(), sv, ec)
       == boost::asio::detail::socket_error_retval)
     return ec;
 
   if (socket1.assign(protocol, sv[0], ec))
   {
     boost::system::error_code temp_ec;
     boost::asio::detail::socket_ops::state_type state[2] = { 0, 0 };
     boost::asio::detail::socket_ops::close(sv[0], state[0], true, temp_ec);
     boost::asio::detail::socket_ops::close(sv[1], state[1], true, temp_ec);
     return ec;
   }
 
   if (socket2.assign(protocol, sv[1], ec))
   {
     boost::system::error_code temp_ec;
     socket1.close(temp_ec);
     boost::asio::detail::socket_ops::state_type state = 0;
     boost::asio::detail::socket_ops::close(sv[1], state, true, temp_ec);
diff --git a/3rdParty/Boost/src/boost/asio/local/datagram_protocol.hpp b/3rdParty/Boost/src/boost/asio/local/datagram_protocol.hpp
index 6fa6323..eaa0241 100644
--- a/3rdParty/Boost/src/boost/asio/local/datagram_protocol.hpp
+++ b/3rdParty/Boost/src/boost/asio/local/datagram_protocol.hpp
@@ -1,40 +1,40 @@
 //
 // local/datagram_protocol.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_LOCAL_DATAGRAM_PROTOCOL_HPP
 #define BOOST_ASIO_LOCAL_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>
 
 #if defined(BOOST_ASIO_HAS_LOCAL_SOCKETS) \
   || defined(GENERATING_DOCUMENTATION)
 
 #include <boost/asio/basic_datagram_socket.hpp>
 #include <boost/asio/detail/socket_types.hpp>
 #include <boost/asio/local/basic_endpoint.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace local {
 
 /// Encapsulates the flags needed for datagram-oriented UNIX sockets.
 /**
  * The boost::asio::local::datagram_protocol class contains flags necessary for
  * datagram-oriented UNIX domain sockets.
  *
  * @par Thread Safety
  * @e Distinct @e objects: Safe.@n
  * @e Shared @e objects: Safe.
diff --git a/3rdParty/Boost/src/boost/asio/local/detail/endpoint.hpp b/3rdParty/Boost/src/boost/asio/local/detail/endpoint.hpp
index 998d371..c527793 100644
--- a/3rdParty/Boost/src/boost/asio/local/detail/endpoint.hpp
+++ b/3rdParty/Boost/src/boost/asio/local/detail/endpoint.hpp
@@ -1,80 +1,80 @@
 //
 // local/detail/endpoint.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2011 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)
 //
 
 #ifndef BOOST_ASIO_LOCAL_DETAIL_ENDPOINT_HPP
 #define BOOST_ASIO_LOCAL_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>
 
 #if defined(BOOST_ASIO_HAS_LOCAL_SOCKETS)
 
 #include <cstddef>
 #include <string>
 #include <boost/asio/detail/socket_types.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace local {
 namespace detail {
 
 // Helper class for implementing a UNIX domain endpoint.
 class endpoint
 {
 public:
   // Default constructor.
   BOOST_ASIO_DECL endpoint();
 
   // Construct an endpoint using the specified path name.
-  BOOST_ASIO_DECL endpoint(const char* path_name);
+  BOOST_ASIO_DECL endpoint(const char* path);
 
   // Construct an endpoint using the specified path name.
-  BOOST_ASIO_DECL endpoint(const std::string& path_name);
+  BOOST_ASIO_DECL endpoint(const std::string& path);
 
   // Copy constructor.
   endpoint(const endpoint& other)
     : data_(other.data_),
       path_length_(other.path_length_)
   {
   }
 
   // Assign from another endpoint.
   endpoint& operator=(const endpoint& other)
   {
     data_ = other.data_;
     path_length_ = other.path_length_;
     return *this;
   }
 
   // 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 path_length_
       + offsetof(boost::asio::detail::sockaddr_un_type, sun_path);
   }
 
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..a4c1e56 100644
--- a/3rdParty/Boost/src/boost/asio/local/detail/impl/endpoint.ipp
+++ b/3rdParty/Boost/src/boost/asio/local/detail/impl/endpoint.ipp
@@ -1,130 +1,130 @@
 //
 // local/detail/impl/endpoint.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2011 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)
 //
 
 #ifndef BOOST_ASIO_LOCAL_DETAIL_IMPL_ENDPOINT_IPP
 #define BOOST_ASIO_LOCAL_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>
 
 #if defined(BOOST_ASIO_HAS_LOCAL_SOCKETS)
 
 #include <cstring>
 #include <boost/asio/detail/socket_ops.hpp>
 #include <boost/asio/detail/throw_error.hpp>
 #include <boost/asio/error.hpp>
 #include <boost/asio/local/detail/endpoint.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace local {
 namespace detail {
 
 endpoint::endpoint()
 {
   init("", 0);
 }
 
-endpoint::endpoint(const char* path_name)
+endpoint::endpoint(const char* path)
 {
   using namespace std; // For strlen.
-  init(path_name, strlen(path_name));
+  init(path, strlen(path));
 }
 
-endpoint::endpoint(const std::string& path_name)
+endpoint::endpoint(const std::string& path)
 {
-  init(path_name.data(), path_name.length());
+  init(path.data(), path.length());
 }
 
-void endpoint::resize(std::size_t new_size)
+void endpoint::resize(std::size_t size)
 {
-  if (new_size > sizeof(boost::asio::detail::sockaddr_un_type))
+  if (size > sizeof(boost::asio::detail::sockaddr_un_type))
   {
     boost::system::error_code ec(boost::asio::error::invalid_argument);
     boost::asio::detail::throw_error(ec);
   }
-  else if (new_size == 0)
+  else if (size == 0)
   {
     path_length_ = 0;
   }
   else
   {
-    path_length_ = new_size
+    path_length_ = size
       - offsetof(boost::asio::detail::sockaddr_un_type, sun_path);
 
     // The path returned by the operating system may be NUL-terminated.
     if (path_length_ > 0 && data_.local.sun_path[path_length_ - 1] == 0)
       --path_length_;
   }
 }
 
 std::string endpoint::path() const
 {
   return std::string(data_.local.sun_path, path_length_);
 }
 
 void endpoint::path(const char* p)
 {
   using namespace std; // For strlen.
   init(p, strlen(p));
 }
 
 void endpoint::path(const std::string& p)
 {
   init(p.data(), p.length());
 }
 
 bool operator==(const endpoint& e1, const endpoint& e2)
 {
   return e1.path() == e2.path();
 }
 
 bool operator<(const endpoint& e1, const endpoint& e2)
 {
   return e1.path() < e2.path();
 }
 
-void endpoint::init(const char* path_name, std::size_t path_length)
+void endpoint::init(const char* path, std::size_t path_length)
 {
   if (path_length > sizeof(data_.local.sun_path) - 1)
   {
     // The buffer is not large enough to store this address.
     boost::system::error_code ec(boost::asio::error::name_too_long);
     boost::asio::detail::throw_error(ec);
   }
 
   using namespace std; // For memcpy.
   data_.local = boost::asio::detail::sockaddr_un_type();
   data_.local.sun_family = AF_UNIX;
-  memcpy(data_.local.sun_path, path_name, path_length);
+  memcpy(data_.local.sun_path, path, path_length);
   path_length_ = path_length;
 
   // NUL-terminate normal path names. Names that start with a NUL are in the
   // UNIX domain protocol's "abstract namespace" and are not NUL-terminated.
   if (path_length > 0 && data_.local.sun_path[0] == 0)
     data_.local.sun_path[path_length] = 0;
 }
 
 } // namespace detail
 } // namespace local
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // defined(BOOST_ASIO_HAS_LOCAL_SOCKETS)
 
 #endif // BOOST_ASIO_LOCAL_DETAIL_IMPL_ENDPOINT_IPP
diff --git a/3rdParty/Boost/src/boost/asio/local/stream_protocol.hpp b/3rdParty/Boost/src/boost/asio/local/stream_protocol.hpp
index c747666..e8692c5 100644
--- a/3rdParty/Boost/src/boost/asio/local/stream_protocol.hpp
+++ b/3rdParty/Boost/src/boost/asio/local/stream_protocol.hpp
@@ -1,40 +1,40 @@
 //
 // local/stream_protocol.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_LOCAL_STREAM_PROTOCOL_HPP
 #define BOOST_ASIO_LOCAL_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>
 
 #if defined(BOOST_ASIO_HAS_LOCAL_SOCKETS) \
   || defined(GENERATING_DOCUMENTATION)
 
 #include <boost/asio/basic_socket_acceptor.hpp>
 #include <boost/asio/basic_socket_iostream.hpp>
 #include <boost/asio/basic_stream_socket.hpp>
 #include <boost/asio/detail/socket_types.hpp>
 #include <boost/asio/local/basic_endpoint.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace local {
 
 /// Encapsulates the flags needed for stream-oriented UNIX sockets.
 /**
  * The boost::asio::local::stream_protocol class contains flags necessary for
  * stream-oriented UNIX domain sockets.
  *
  * @par Thread Safety
diff --git a/3rdParty/Boost/src/boost/asio/placeholders.hpp b/3rdParty/Boost/src/boost/asio/placeholders.hpp
index d4bf743..19ddb66 100644
--- a/3rdParty/Boost/src/boost/asio/placeholders.hpp
+++ b/3rdParty/Boost/src/boost/asio/placeholders.hpp
@@ -1,122 +1,108 @@
 //
 // placeholders.hpp
 // ~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_PLACEHOLDERS_HPP
 #define BOOST_ASIO_PLACEHOLDERS_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/bind/arg.hpp>
 #include <boost/detail/workaround.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace placeholders {
 
 #if defined(GENERATING_DOCUMENTATION)
 
 /// An argument placeholder, for use with boost::bind(), that corresponds to
 /// the error argument of a handler for any of the asynchronous functions.
 unspecified error;
 
 /// An argument placeholder, for use with boost::bind(), that corresponds to
 /// the bytes_transferred argument of a handler for asynchronous functions such
 /// as boost::asio::basic_stream_socket::async_write_some or
 /// boost::asio::async_write.
 unspecified bytes_transferred;
 
 /// An argument placeholder, for use with boost::bind(), that corresponds to
 /// the iterator argument of a handler for asynchronous functions such as
 /// boost::asio::basic_resolver::async_resolve.
 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__)
 
 inline boost::arg<1> error()
 {
   return boost::arg<1>();
 }
 
 inline boost::arg<2> bytes_transferred()
 {
   return boost::arg<2>();
 }
 
 inline boost::arg<2> iterator()
 {
   return boost::arg<2>();
 }
 
-inline boost::arg<2> signal_number()
-{
-  return boost::arg<2>();
-}
-
 #else
 
 namespace detail
 {
   template <int Number>
   struct placeholder
   {
     static boost::arg<Number>& get()
     {
       static boost::arg<Number> result;
       return result;
     }
   };
 }
 
 #if BOOST_WORKAROUND(BOOST_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
 
 namespace
 {
   boost::arg<1>& error
     = boost::asio::placeholders::detail::placeholder<1>::get();
   boost::arg<2>& bytes_transferred
     = boost::asio::placeholders::detail::placeholder<2>::get();
   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
 
 } // namespace placeholders
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // BOOST_ASIO_PLACEHOLDERS_HPP
diff --git a/3rdParty/Boost/src/boost/asio/posix/basic_descriptor.hpp b/3rdParty/Boost/src/boost/asio/posix/basic_descriptor.hpp
index d4af5a4..cf953db 100644
--- a/3rdParty/Boost/src/boost/asio/posix/basic_descriptor.hpp
+++ b/3rdParty/Boost/src/boost/asio/posix/basic_descriptor.hpp
@@ -1,492 +1,300 @@
 //
 // posix/basic_descriptor.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_POSIX_BASIC_DESCRIPTOR_HPP
 #define BOOST_ASIO_POSIX_BASIC_DESCRIPTOR_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_POSIX_STREAM_DESCRIPTOR) \
   || defined(GENERATING_DOCUMENTATION)
 
 #include <boost/asio/basic_io_object.hpp>
 #include <boost/asio/detail/throw_error.hpp>
 #include <boost/asio/error.hpp>
 #include <boost/asio/posix/descriptor_base.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace posix {
 
 /// Provides POSIX descriptor functionality.
 /**
  * The posix::basic_descriptor class template provides the ability to wrap a
  * POSIX descriptor.
  *
  * @par Thread Safety
  * @e Distinct @e objects: Safe.@n
  * @e Shared @e objects: Unsafe.
  */
 template <typename DescriptorService>
 class basic_descriptor
   : public basic_io_object<DescriptorService>,
     public descriptor_base
 {
 public:
-  /// (Deprecated: Use native_handle_type.) The native representation of a
-  /// descriptor.
-  typedef typename DescriptorService::native_handle_type native_type;
-
   /// The native representation of a descriptor.
-  typedef typename DescriptorService::native_handle_type native_handle_type;
+  typedef typename DescriptorService::native_type native_type;
 
   /// A basic_descriptor is always the lowest layer.
   typedef basic_descriptor<DescriptorService> lowest_layer_type;
 
   /// Construct a basic_descriptor without opening it.
   /**
    * This constructor creates a descriptor without opening it.
    *
    * @param io_service The io_service object that the descriptor will use to
    * dispatch handlers for any asynchronous operations performed on the
    * descriptor.
    */
   explicit basic_descriptor(boost::asio::io_service& io_service)
     : basic_io_object<DescriptorService>(io_service)
   {
   }
 
   /// Construct a basic_descriptor on an existing native descriptor.
   /**
    * This constructor creates a descriptor object to hold an existing native
    * descriptor.
    *
    * @param io_service The io_service object that the descriptor will use to
    * dispatch handlers for any asynchronous operations performed on the
    * descriptor.
    *
    * @param native_descriptor A native descriptor.
    *
    * @throws boost::system::system_error Thrown on failure.
    */
   basic_descriptor(boost::asio::io_service& io_service,
-      const native_handle_type& native_descriptor)
+      const native_type& native_descriptor)
     : basic_io_object<DescriptorService>(io_service)
   {
     boost::system::error_code ec;
-    this->get_service().assign(this->get_implementation(),
-        native_descriptor, ec);
-    boost::asio::detail::throw_error(ec, "assign");
+    this->service.assign(this->implementation, native_descriptor, ec);
+    boost::asio::detail::throw_error(ec);
   }
 
-#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
-  /// Move-construct a basic_descriptor from another.
-  /**
-   * This constructor moves a descriptor from one object to another.
-   *
-   * @param other The other basic_descriptor 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_descriptor(io_service&) constructor.
-   */
-  basic_descriptor(basic_descriptor&& other)
-    : basic_io_object<DescriptorService>(
-        BOOST_ASIO_MOVE_CAST(basic_descriptor)(other))
-  {
-  }
-
-  /// Move-assign a basic_descriptor from another.
-  /**
-   * This assignment operator moves a descriptor from one object to another.
-   *
-   * @param other The other basic_descriptor 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_descriptor(io_service&) constructor.
-   */
-  basic_descriptor& operator=(basic_descriptor&& other)
-  {
-    basic_io_object<DescriptorService>::operator=(
-        BOOST_ASIO_MOVE_CAST(basic_descriptor)(other));
-    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_descriptor cannot contain any further layers, it
    * simply returns a reference to itself.
    *
    * @return A reference to the lowest layer in the stack of layers. Ownership
    * is not transferred to the caller.
    */
   lowest_layer_type& lowest_layer()
   {
     return *this;
   }
 
   /// Get a const reference to the lowest layer.
   /**
    * This function returns a const reference to the lowest layer in a stack of
    * layers. Since a basic_descriptor cannot contain any further layers, it
    * simply returns a reference to itself.
    *
    * @return A const reference to the lowest layer in the stack of layers.
    * Ownership is not transferred to the caller.
    */
   const lowest_layer_type& lowest_layer() const
   {
     return *this;
   }
 
   /// Assign an existing native descriptor to the descriptor.
   /*
    * This function opens the descriptor to hold an existing native descriptor.
    *
    * @param native_descriptor A native descriptor.
    *
    * @throws boost::system::system_error Thrown on failure.
    */
-  void assign(const native_handle_type& native_descriptor)
+  void assign(const native_type& native_descriptor)
   {
     boost::system::error_code ec;
-    this->get_service().assign(this->get_implementation(),
-        native_descriptor, ec);
-    boost::asio::detail::throw_error(ec, "assign");
+    this->service.assign(this->implementation, native_descriptor, ec);
+    boost::asio::detail::throw_error(ec);
   }
 
   /// Assign an existing native descriptor to the descriptor.
   /*
    * This function opens the descriptor to hold an existing native descriptor.
    *
    * @param native_descriptor A native descriptor.
    *
    * @param ec Set to indicate what error occurred, if any.
    */
-  boost::system::error_code assign(const native_handle_type& native_descriptor,
+  boost::system::error_code assign(const native_type& native_descriptor,
       boost::system::error_code& ec)
   {
-    return this->get_service().assign(
-        this->get_implementation(), native_descriptor, ec);
+    return this->service.assign(this->implementation, native_descriptor, ec);
   }
 
   /// Determine whether the descriptor is open.
   bool is_open() const
   {
-    return this->get_service().is_open(this->implementation);
+    return this->service.is_open(this->implementation);
   }
 
   /// Close the descriptor.
   /**
    * This function is used to close the descriptor. Any asynchronous read or
    * write operations will be cancelled immediately, and will complete with the
    * boost::asio::error::operation_aborted error.
    *
-   * @throws boost::system::system_error Thrown on failure. Note that, even if
-   * the function indicates an error, the underlying descriptor is closed.
+   * @throws boost::system::system_error Thrown on failure.
    */
   void close()
   {
     boost::system::error_code ec;
-    this->get_service().close(this->get_implementation(), ec);
-    boost::asio::detail::throw_error(ec, "close");
+    this->service.close(this->implementation, ec);
+    boost::asio::detail::throw_error(ec);
   }
 
   /// Close the descriptor.
   /**
    * This function is used to close the descriptor. Any asynchronous read or
    * write operations will be cancelled immediately, and will complete with the
    * boost::asio::error::operation_aborted error.
    *
-   * @param ec Set to indicate what error occurred, if any. Note that, even if
-   * the function indicates an error, the underlying descriptor is closed.
+   * @param ec Set to indicate what error occurred, if any.
    */
   boost::system::error_code close(boost::system::error_code& ec)
   {
-    return this->get_service().close(this->get_implementation(), ec);
-  }
-
-  /// (Deprecated: Use native_handle().) Get the native descriptor
-  /// representation.
-  /**
-   * This function may be used to obtain the underlying representation of the
-   * descriptor. This is intended to allow access to native descriptor
-   * functionality that is not otherwise provided.
-   */
-  native_type native()
-  {
-    return this->get_service().native_handle(this->implementation);
+    return this->service.close(this->implementation, ec);
   }
 
   /// Get the native descriptor representation.
   /**
    * This function may be used to obtain the underlying representation of the
    * descriptor. This is intended to allow access to native descriptor
    * functionality that is not otherwise provided.
    */
-  native_handle_type native_handle()
-  {
-    return this->get_service().native_handle(this->implementation);
-  }
-
-  /// Release ownership of the native descriptor implementation.
-  /**
-   * This function may be used to obtain the underlying representation of the
-   * descriptor. After calling this function, @c is_open() returns false. The
-   * caller is responsible for closing the descriptor.
-   *
-   * All outstanding asynchronous read or write operations will finish
-   * immediately, and the handlers for cancelled operations will be passed the
-   * boost::asio::error::operation_aborted error.
-   */
-  native_handle_type release()
+  native_type native()
   {
-    return this->get_service().release(this->implementation);
+    return this->service.native(this->implementation);
   }
 
   /// Cancel all asynchronous operations associated with the descriptor.
   /**
    * This function causes all outstanding asynchronous read or write operations
    * to finish immediately, and the handlers for cancelled operations will be
    * passed the boost::asio::error::operation_aborted error.
    *
    * @throws boost::system::system_error Thrown on failure.
    */
   void cancel()
   {
     boost::system::error_code ec;
-    this->get_service().cancel(this->get_implementation(), ec);
-    boost::asio::detail::throw_error(ec, "cancel");
+    this->service.cancel(this->implementation, ec);
+    boost::asio::detail::throw_error(ec);
   }
 
   /// Cancel all asynchronous operations associated with the descriptor.
   /**
    * This function causes all outstanding asynchronous read or write operations
    * to finish immediately, and the handlers for cancelled operations will be
    * passed the boost::asio::error::operation_aborted error.
    *
    * @param ec Set to indicate what error occurred, if any.
    */
   boost::system::error_code cancel(boost::system::error_code& ec)
   {
-    return this->get_service().cancel(this->get_implementation(), ec);
+    return this->service.cancel(this->implementation, ec);
   }
 
   /// Perform an IO control command on the descriptor.
   /**
    * This function is used to execute an IO control command on the descriptor.
    *
    * @param command The IO control command to be performed on the descriptor.
    *
    * @throws boost::system::system_error Thrown on failure.
    *
    * @sa IoControlCommand @n
    * boost::asio::posix::descriptor_base::bytes_readable @n
    * boost::asio::posix::descriptor_base::non_blocking_io
    *
    * @par Example
    * Getting the number of bytes ready to read:
    * @code
    * boost::asio::posix::stream_descriptor descriptor(io_service);
    * ...
    * boost::asio::posix::stream_descriptor::bytes_readable command;
    * descriptor.io_control(command);
    * std::size_t bytes_readable = command.get();
    * @endcode
    */
   template <typename IoControlCommand>
   void io_control(IoControlCommand& command)
   {
     boost::system::error_code ec;
-    this->get_service().io_control(this->get_implementation(), command, ec);
-    boost::asio::detail::throw_error(ec, "io_control");
+    this->service.io_control(this->implementation, command, ec);
+    boost::asio::detail::throw_error(ec);
   }
 
   /// Perform an IO control command on the descriptor.
   /**
    * This function is used to execute an IO control command on the descriptor.
    *
    * @param command The IO control command to be performed on the descriptor.
    *
    * @param ec Set to indicate what error occurred, if any.
    *
    * @sa IoControlCommand @n
    * boost::asio::posix::descriptor_base::bytes_readable @n
    * boost::asio::posix::descriptor_base::non_blocking_io
    *
    * @par Example
    * Getting the number of bytes ready to read:
    * @code
    * boost::asio::posix::stream_descriptor descriptor(io_service);
    * ...
    * boost::asio::posix::stream_descriptor::bytes_readable command;
    * boost::system::error_code ec;
    * descriptor.io_control(command, ec);
    * if (ec)
    * {
    *   // An error occurred.
    * }
    * std::size_t bytes_readable = command.get();
    * @endcode
    */
   template <typename IoControlCommand>
   boost::system::error_code io_control(IoControlCommand& command,
       boost::system::error_code& ec)
   {
-    return this->get_service().io_control(
-        this->get_implementation(), command, ec);
-  }
-
-  /// Gets the non-blocking mode of the descriptor.
-  /**
-   * @returns @c true if the descriptor's synchronous operations will fail with
-   * boost::asio::error::would_block if they are unable to perform the requested
-   * operation immediately. If @c false, synchronous operations will block
-   * until complete.
-   *
-   * @note The non-blocking mode has no effect on the behaviour of asynchronous
-   * operations. Asynchronous operations will never fail with the error
-   * boost::asio::error::would_block.
-   */
-  bool non_blocking() const
-  {
-    return this->get_service().non_blocking(this->implementation);
-  }
-
-  /// Sets the non-blocking mode of the descriptor.
-  /**
-   * @param mode If @c true, the descriptor's synchronous operations will fail
-   * with boost::asio::error::would_block if they are unable to perform the
-   * requested operation immediately. If @c false, synchronous operations will
-   * block until complete.
-   *
-   * @throws boost::system::system_error Thrown on failure.
-   *
-   * @note The non-blocking mode has no effect on the behaviour of asynchronous
-   * operations. Asynchronous operations will never fail with the error
-   * boost::asio::error::would_block.
-   */
-  void non_blocking(bool mode)
-  {
-    boost::system::error_code ec;
-    this->get_service().non_blocking(this->get_implementation(), mode, ec);
-    boost::asio::detail::throw_error(ec, "non_blocking");
-  }
-
-  /// Sets the non-blocking mode of the descriptor.
-  /**
-   * @param mode If @c true, the descriptor's synchronous operations will fail
-   * with boost::asio::error::would_block if they are unable to perform the
-   * requested operation immediately. If @c false, synchronous operations will
-   * block until complete.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   *
-   * @note The non-blocking mode has no effect on the behaviour of asynchronous
-   * operations. Asynchronous operations will never fail with the error
-   * boost::asio::error::would_block.
-   */
-  boost::system::error_code non_blocking(
-      bool mode, boost::system::error_code& ec)
-  {
-    return this->get_service().non_blocking(
-        this->get_implementation(), mode, ec);
-  }
-
-  /// Gets the non-blocking mode of the native descriptor implementation.
-  /**
-   * This function is used to retrieve the non-blocking mode of the underlying
-   * native descriptor. This mode has no effect on the behaviour of the
-   * descriptor object's synchronous operations.
-   *
-   * @returns @c true if the underlying descriptor is in non-blocking mode and
-   * direct system calls may fail with boost::asio::error::would_block (or the
-   * equivalent system error).
-   *
-   * @note The current non-blocking mode is cached by the descriptor object.
-   * Consequently, the return value may be incorrect if the non-blocking mode
-   * was set directly on the native descriptor.
-   */
-  bool native_non_blocking() const
-  {
-    return this->get_service().native_non_blocking(this->implementation);
-  }
-
-  /// Sets the non-blocking mode of the native descriptor implementation.
-  /**
-   * This function is used to modify the non-blocking mode of the underlying
-   * native descriptor. It has no effect on the behaviour of the descriptor
-   * object's synchronous operations.
-   *
-   * @param mode If @c true, the underlying descriptor is put into non-blocking
-   * mode and direct system calls may fail with boost::asio::error::would_block
-   * (or the equivalent system error).
-   *
-   * @throws boost::system::system_error Thrown on failure. If the @c mode is
-   * @c false, but the current value of @c non_blocking() is @c true, this
-   * function fails with boost::asio::error::invalid_argument, as the
-   * combination does not make sense.
-   */
-  void native_non_blocking(bool mode)
-  {
-    boost::system::error_code ec;
-    this->get_service().native_non_blocking(
-        this->get_implementation(), mode, ec);
-    boost::asio::detail::throw_error(ec, "native_non_blocking");
-  }
-
-  /// Sets the non-blocking mode of the native descriptor implementation.
-  /**
-   * This function is used to modify the non-blocking mode of the underlying
-   * native descriptor. It has no effect on the behaviour of the descriptor
-   * object's synchronous operations.
-   *
-   * @param mode If @c true, the underlying descriptor is put into non-blocking
-   * mode and direct system calls may fail with boost::asio::error::would_block
-   * (or the equivalent system error).
-   *
-   * @param ec Set to indicate what error occurred, if any. If the @c mode is
-   * @c false, but the current value of @c non_blocking() is @c true, this
-   * function fails with boost::asio::error::invalid_argument, as the
-   * combination does not make sense.
-   */
-  boost::system::error_code native_non_blocking(
-      bool mode, boost::system::error_code& ec)
-  {
-    return this->get_service().native_non_blocking(
-        this->get_implementation(), mode, ec);
+    return this->service.io_control(this->implementation, command, ec);
   }
 
 protected:
   /// Protected destructor to prevent deletion through this type.
   ~basic_descriptor()
   {
   }
 };
 
 } // namespace posix
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // defined(BOOST_ASIO_HAS_POSIX_STREAM_DESCRIPTOR)
        //   || defined(GENERATING_DOCUMENTATION)
 
 #endif // 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..ee08567 100644
--- a/3rdParty/Boost/src/boost/asio/posix/basic_stream_descriptor.hpp
+++ b/3rdParty/Boost/src/boost/asio/posix/basic_stream_descriptor.hpp
@@ -1,360 +1,304 @@
 //
 // posix/basic_stream_descriptor.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_POSIX_BASIC_STREAM_DESCRIPTOR_HPP
 #define BOOST_ASIO_POSIX_BASIC_STREAM_DESCRIPTOR_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_POSIX_STREAM_DESCRIPTOR) \
   || defined(GENERATING_DOCUMENTATION)
 
 #include <cstddef>
-#include <boost/asio/detail/handler_type_requirements.hpp>
 #include <boost/asio/detail/throw_error.hpp>
 #include <boost/asio/error.hpp>
 #include <boost/asio/posix/basic_descriptor.hpp>
 #include <boost/asio/posix/stream_descriptor_service.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace posix {
 
 /// Provides stream-oriented descriptor functionality.
 /**
  * The posix::basic_stream_descriptor class template provides asynchronous and
  * blocking stream-oriented descriptor functionality.
  *
  * @par Thread Safety
  * @e Distinct @e objects: Safe.@n
  * @e Shared @e objects: Unsafe.
  *
  * @par Concepts:
  * AsyncReadStream, AsyncWriteStream, Stream, SyncReadStream, SyncWriteStream.
  */
 template <typename StreamDescriptorService = stream_descriptor_service>
 class basic_stream_descriptor
   : public basic_descriptor<StreamDescriptorService>
 {
 public:
-  /// (Deprecated: Use native_handle_type.) The native representation of a
-  /// descriptor.
-  typedef typename StreamDescriptorService::native_handle_type native_type;
-
   /// The native representation of a descriptor.
-  typedef typename StreamDescriptorService::native_handle_type
-    native_handle_type;
+  typedef typename StreamDescriptorService::native_type native_type;
 
   /// Construct a basic_stream_descriptor without opening it.
   /**
    * This constructor creates a stream descriptor without opening it. The
    * descriptor needs to be opened and then connected or accepted before data
    * can be sent or received on it.
    *
    * @param io_service The io_service object that the stream descriptor will
    * use to dispatch handlers for any asynchronous operations performed on the
    * descriptor.
    */
   explicit basic_stream_descriptor(boost::asio::io_service& io_service)
     : basic_descriptor<StreamDescriptorService>(io_service)
   {
   }
 
   /// Construct a basic_stream_descriptor on an existing native descriptor.
   /**
    * This constructor creates a stream descriptor object to hold an existing
    * native descriptor.
    *
    * @param io_service The io_service object that the stream descriptor will
    * use to dispatch handlers for any asynchronous operations performed on the
    * descriptor.
    *
    * @param native_descriptor The new underlying descriptor implementation.
    *
    * @throws boost::system::system_error Thrown on failure.
    */
   basic_stream_descriptor(boost::asio::io_service& io_service,
-      const native_handle_type& native_descriptor)
+      const native_type& native_descriptor)
     : basic_descriptor<StreamDescriptorService>(io_service, native_descriptor)
   {
   }
 
-#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
-  /// Move-construct a basic_stream_descriptor from another.
-  /**
-   * This constructor moves a stream descriptor from one object to another.
-   *
-   * @param other The other basic_stream_descriptor 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_descriptor(io_service&) constructor.
-   */
-  basic_stream_descriptor(basic_stream_descriptor&& other)
-    : basic_descriptor<StreamDescriptorService>(
-        BOOST_ASIO_MOVE_CAST(basic_stream_descriptor)(other))
-  {
-  }
-
-  /// Move-assign a basic_stream_descriptor from another.
-  /**
-   * This assignment operator moves a stream descriptor from one object to
-   * another.
-   *
-   * @param other The other basic_stream_descriptor 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_descriptor(io_service&) constructor.
-   */
-  basic_stream_descriptor& operator=(basic_stream_descriptor&& other)
-  {
-    basic_descriptor<StreamDescriptorService>::operator=(
-        BOOST_ASIO_MOVE_CAST(basic_stream_descriptor)(other));
-    return *this;
-  }
-#endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
-
   /// Write some data to the descriptor.
   /**
    * This function is used to write data to the stream descriptor. The function
    * call will block until one or more bytes of the data has been written
    * successfully, or until an error occurs.
    *
    * @param buffers One or more data buffers to be written to the descriptor.
    *
    * @returns The number of bytes written.
    *
    * @throws boost::system::system_error Thrown on failure. An error code of
    * boost::asio::error::eof indicates that the connection was closed by the
    * peer.
    *
    * @note The write_some operation may not transmit all of the data to the
    * peer. Consider using the @ref write function if you need to ensure that
    * all data is written before the blocking operation completes.
    *
    * @par Example
    * To write a single data buffer use the @ref buffer function as follows:
    * @code
    * descriptor.write_some(boost::asio::buffer(data, size));
    * @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(const ConstBufferSequence& buffers)
   {
     boost::system::error_code ec;
-    std::size_t s = this->get_service().write_some(
-        this->get_implementation(), buffers, ec);
-    boost::asio::detail::throw_error(ec, "write_some");
+    std::size_t s = this->service.write_some(this->implementation, buffers, ec);
+    boost::asio::detail::throw_error(ec);
     return s;
   }
 
   /// Write some data to the descriptor.
   /**
    * This function is used to write data to the stream descriptor. The function
    * call will block until one or more bytes of the data has been written
    * successfully, or until an error occurs.
    *
    * @param buffers One or more data buffers to be written to the descriptor.
    *
    * @param ec Set to indicate what error occurred, if any.
    *
    * @returns The number of bytes written. Returns 0 if an error occurred.
    *
    * @note The write_some operation may not transmit all of the data to the
    * peer. Consider using the @ref write function if you need to ensure that
    * all data is written before the blocking operation completes.
    */
   template <typename ConstBufferSequence>
   std::size_t write_some(const ConstBufferSequence& buffers,
       boost::system::error_code& ec)
   {
-    return this->get_service().write_some(
-        this->get_implementation(), buffers, ec);
+    return this->service.write_some(this->implementation, buffers, ec);
   }
 
   /// Start an asynchronous write.
   /**
    * This function is used to asynchronously write data to the stream
    * descriptor. The function call always returns immediately.
    *
    * @param buffers One or more data buffers to be written to the descriptor.
    * 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.
    *
    * @param handler The handler to be called when the write operation completes.
    * Copies will be made of the handler as required. The function signature of
    * the handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
    *   std::size_t bytes_transferred           // Number of bytes written.
    * ); @endcode
    * 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().
    *
    * @note The write operation may not transmit all of the data to the peer.
    * Consider using the @ref async_write function if you need to ensure that all
    * data is written before the asynchronous operation completes.
    *
    * @par Example
    * To write a single data buffer use the @ref buffer function as follows:
    * @code
    * descriptor.async_write_some(boost::asio::buffer(data, size), handler);
    * @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_MOVE_ARG(WriteHandler) handler)
+      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(),
-        buffers, BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
+    this->service.async_write_some(this->implementation, buffers, handler);
   }
 
   /// Read some data from the descriptor.
   /**
    * This function is used to read data from the stream descriptor. The function
    * call will block until one or more bytes of data has been read successfully,
    * or until an error occurs.
    *
    * @param buffers One or more buffers into which the data will be read.
    *
    * @returns The number of bytes read.
    *
    * @throws boost::system::system_error Thrown on failure. An error code of
    * boost::asio::error::eof indicates that the connection was closed by the
    * peer.
    *
    * @note The read_some operation may not read all of the requested number of
    * bytes. Consider using the @ref read function if you need to ensure that
    * the requested amount of data is read before the blocking operation
    * completes.
    *
    * @par Example
    * To read into a single data buffer use the @ref buffer function as follows:
    * @code
    * descriptor.read_some(boost::asio::buffer(data, size));
    * @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(const MutableBufferSequence& buffers)
   {
     boost::system::error_code ec;
-    std::size_t s = this->get_service().read_some(
-        this->get_implementation(), buffers, ec);
-    boost::asio::detail::throw_error(ec, "read_some");
+    std::size_t s = this->service.read_some(this->implementation, buffers, ec);
+    boost::asio::detail::throw_error(ec);
     return s;
   }
 
   /// Read some data from the descriptor.
   /**
    * This function is used to read data from the stream descriptor. The function
    * call will block until one or more bytes of data has been read successfully,
    * or until an error occurs.
    *
    * @param buffers One or more buffers into which the data will be read.
    *
    * @param ec Set to indicate what error occurred, if any.
    *
    * @returns The number of bytes read. Returns 0 if an error occurred.
    *
    * @note The read_some operation may not read all of the requested number of
    * bytes. Consider using the @ref read 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(const MutableBufferSequence& buffers,
       boost::system::error_code& ec)
   {
-    return this->get_service().read_some(
-        this->get_implementation(), buffers, ec);
+    return this->service.read_some(this->implementation, buffers, ec);
   }
 
   /// Start an asynchronous read.
   /**
    * This function is used to asynchronously read data from the stream
    * descriptor. The function call always returns immediately.
    *
    * @param buffers One or more buffers into which the data will be read.
    * 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.
    *
    * @param handler The handler to be called when the read operation completes.
    * Copies will be made of the handler as required. The function signature of
    * the handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
    *   std::size_t bytes_transferred           // Number of bytes read.
    * ); @endcode
    * 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().
    *
    * @note The read operation may not read all of the requested number of bytes.
    * Consider using the @ref async_read function if you need to ensure that the
    * requested amount of data is read before the asynchronous operation
    * completes.
    *
    * @par Example
    * To read into a single data buffer use the @ref buffer function as follows:
    * @code
    * descriptor.async_read_some(boost::asio::buffer(data, size), handler);
    * @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_MOVE_ARG(ReadHandler) handler)
+      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(),
-        buffers, BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
+    this->service.async_read_some(this->implementation, buffers, handler);
   }
 };
 
 } // namespace posix
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // defined(BOOST_ASIO_HAS_POSIX_STREAM_DESCRIPTOR)
        //   || defined(GENERATING_DOCUMENTATION)
 
 #endif // BOOST_ASIO_POSIX_BASIC_STREAM_DESCRIPTOR_HPP
diff --git a/3rdParty/Boost/src/boost/asio/posix/descriptor_base.hpp b/3rdParty/Boost/src/boost/asio/posix/descriptor_base.hpp
index c75b85a..2e5cb47 100644
--- a/3rdParty/Boost/src/boost/asio/posix/descriptor_base.hpp
+++ b/3rdParty/Boost/src/boost/asio/posix/descriptor_base.hpp
@@ -1,74 +1,73 @@
 //
 // posix/descriptor_base.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_POSIX_DESCRIPTOR_BASE_HPP
 #define BOOST_ASIO_POSIX_DESCRIPTOR_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_HAS_POSIX_STREAM_DESCRIPTOR) \
   || defined(GENERATING_DOCUMENTATION)
 
 #include <boost/asio/detail/io_control.hpp>
 #include <boost/asio/detail/socket_option.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace posix {
 
 /// The descriptor_base class is used as a base for the basic_stream_descriptor
 /// class template so that we have a common place to define the associated
 /// IO control commands.
 class descriptor_base
 {
 public:
-  /// (Deprecated: Use non_blocking().) IO control command to set the blocking
-  /// mode of the descriptor.
+  /// IO control command to set the blocking mode of the descriptor.
   /**
    * Implements the FIONBIO IO control command.
    *
    * @par Example
    * @code
    * boost::asio::posix::stream_descriptor descriptor(io_service); 
    * ...
    * boost::asio::descriptor_base::non_blocking_io command(true);
    * descriptor.io_control(command);
    * @endcode
    *
    * @par Concepts:
    * IoControlCommand.
    */
 #if defined(GENERATING_DOCUMENTATION)
   typedef implementation_defined non_blocking_io;
 #else
   typedef boost::asio::detail::io_control::non_blocking_io non_blocking_io;
 #endif
 
   /// IO control command to get the amount of data that can be read without
   /// blocking.
   /**
    * Implements the FIONREAD IO control command.
    *
    * @par Example
    * @code
    * boost::asio::posix::stream_descriptor descriptor(io_service); 
    * ...
    * boost::asio::descriptor_base::bytes_readable command(true);
    * descriptor.io_control(command);
    * std::size_t bytes_readable = command.get();
    * @endcode
    *
    * @par Concepts:
diff --git a/3rdParty/Boost/src/boost/asio/posix/stream_descriptor.hpp b/3rdParty/Boost/src/boost/asio/posix/stream_descriptor.hpp
index 9078107..22551ab 100644
--- a/3rdParty/Boost/src/boost/asio/posix/stream_descriptor.hpp
+++ b/3rdParty/Boost/src/boost/asio/posix/stream_descriptor.hpp
@@ -1,39 +1,39 @@
 //
 // posix/stream_descriptor.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_POSIX_STREAM_DESCRIPTOR_HPP
 #define BOOST_ASIO_POSIX_STREAM_DESCRIPTOR_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_POSIX_STREAM_DESCRIPTOR) \
   || defined(GENERATING_DOCUMENTATION)
 
 #include <boost/asio/posix/basic_stream_descriptor.hpp>
 
 namespace boost {
 namespace asio {
 namespace posix {
 
 /// Typedef for the typical usage of a stream-oriented descriptor.
 typedef basic_stream_descriptor<> stream_descriptor;
 
 } // namespace posix
 } // namespace asio
 } // namespace boost
 
 #endif // defined(BOOST_ASIO_HAS_POSIX_STREAM_DESCRIPTOR)
        //   || defined(GENERATING_DOCUMENTATION)
 
 #endif // 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..c582b8e 100644
--- a/3rdParty/Boost/src/boost/asio/posix/stream_descriptor_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/posix/stream_descriptor_service.hpp
@@ -1,247 +1,179 @@
 //
 // posix/stream_descriptor_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_POSIX_STREAM_DESCRIPTOR_SERVICE_HPP
 #define BOOST_ASIO_POSIX_STREAM_DESCRIPTOR_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_HAS_POSIX_STREAM_DESCRIPTOR) \
   || defined(GENERATING_DOCUMENTATION)
 
 #include <cstddef>
 #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>
 
 namespace boost {
 namespace asio {
 namespace posix {
 
 /// Default service implementation for a stream descriptor.
 class stream_descriptor_service
 #if defined(GENERATING_DOCUMENTATION)
   : public boost::asio::io_service::service
 #else
   : public boost::asio::detail::service_base<stream_descriptor_service>
 #endif
 {
 public:
 #if defined(GENERATING_DOCUMENTATION)
   /// The unique service identifier.
   static boost::asio::io_service::id id;
 #endif
 
 private:
   // The type of the platform-specific implementation.
   typedef detail::reactive_descriptor_service service_impl_type;
 
 public:
   /// The type of a stream descriptor implementation.
 #if defined(GENERATING_DOCUMENTATION)
   typedef implementation_defined implementation_type;
 #else
   typedef service_impl_type::implementation_type implementation_type;
 #endif
 
-  /// (Deprecated: Use native_handle_type.) The native descriptor type.
-#if defined(GENERATING_DOCUMENTATION)
-  typedef implementation_defined native_type;
-#else
-  typedef service_impl_type::native_handle_type native_type;
-#endif
-
   /// The native descriptor type.
 #if defined(GENERATING_DOCUMENTATION)
-  typedef implementation_defined native_handle_type;
+  typedef implementation_defined native_type;
 #else
-  typedef service_impl_type::native_handle_type native_handle_type;
+  typedef service_impl_type::native_type native_type;
 #endif
 
   /// Construct a new stream descriptor service for the specified io_service.
   explicit stream_descriptor_service(boost::asio::io_service& io_service)
     : boost::asio::detail::service_base<stream_descriptor_service>(io_service),
       service_impl_(io_service)
   {
   }
 
-  /// Construct a new stream descriptor implementation.
-  void construct(implementation_type& impl)
-  {
-    service_impl_.construct(impl);
-  }
-
-#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
-  /// Move-construct a new stream descriptor implementation.
-  void move_construct(implementation_type& impl,
-      implementation_type& other_impl)
+  /// Destroy all user-defined descriptorr objects owned by the service.
+  void shutdown_service()
   {
-    service_impl_.move_construct(impl, other_impl);
+    service_impl_.shutdown_service();
   }
 
-  /// Move-assign from another stream descriptor implementation.
-  void move_assign(implementation_type& impl,
-      stream_descriptor_service& other_service,
-      implementation_type& other_impl)
+  /// Construct a new stream descriptor implementation.
+  void construct(implementation_type& impl)
   {
-    service_impl_.move_assign(impl, other_service.service_impl_, other_impl);
+    service_impl_.construct(impl);
   }
-#endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
 
   /// Destroy a stream descriptor implementation.
   void destroy(implementation_type& impl)
   {
     service_impl_.destroy(impl);
   }
 
   /// Assign an existing native descriptor to a stream descriptor.
   boost::system::error_code assign(implementation_type& impl,
-      const native_handle_type& native_descriptor,
-      boost::system::error_code& ec)
+      const native_type& native_descriptor, boost::system::error_code& ec)
   {
     return service_impl_.assign(impl, native_descriptor, ec);
   }
 
   /// Determine whether the descriptor is open.
   bool is_open(const implementation_type& impl) const
   {
     return service_impl_.is_open(impl);
   }
 
   /// Close a stream descriptor implementation.
   boost::system::error_code close(implementation_type& impl,
       boost::system::error_code& ec)
   {
     return service_impl_.close(impl, ec);
   }
 
-  /// (Deprecated: Use native_handle().) Get the native descriptor
-  /// implementation.
-  native_type native(implementation_type& impl)
-  {
-    return service_impl_.native_handle(impl);
-  }
-
   /// Get the native descriptor implementation.
-  native_handle_type native_handle(implementation_type& impl)
-  {
-    return service_impl_.native_handle(impl);
-  }
-
-  /// Release ownership of the native descriptor implementation.
-  native_handle_type release(implementation_type& impl)
+  native_type native(implementation_type& impl)
   {
-    return service_impl_.release(impl);
+    return service_impl_.native(impl);
   }
 
   /// Cancel all asynchronous operations associated with the descriptor.
   boost::system::error_code cancel(implementation_type& impl,
       boost::system::error_code& ec)
   {
     return service_impl_.cancel(impl, ec);
   }
 
   /// Perform an IO control command on the descriptor.
   template <typename IoControlCommand>
   boost::system::error_code io_control(implementation_type& impl,
       IoControlCommand& command, boost::system::error_code& ec)
   {
     return service_impl_.io_control(impl, command, ec);
   }
 
-  /// Gets the non-blocking mode of the descriptor.
-  bool non_blocking(const implementation_type& impl) const
-  {
-    return service_impl_.non_blocking(impl);
-  }
-
-  /// Sets the non-blocking mode of the descriptor.
-  boost::system::error_code non_blocking(implementation_type& impl,
-      bool mode, boost::system::error_code& ec)
-  {
-    return service_impl_.non_blocking(impl, mode, ec);
-  }
-
-  /// Gets the non-blocking mode of the native descriptor implementation.
-  bool native_non_blocking(const implementation_type& impl) const
-  {
-    return service_impl_.native_non_blocking(impl);
-  }
-
-  /// Sets the non-blocking mode of the native descriptor implementation.
-  boost::system::error_code native_non_blocking(implementation_type& impl,
-      bool mode, boost::system::error_code& ec)
-  {
-    return service_impl_.native_non_blocking(impl, mode, ec);
-  }
-
   /// Write the given data to the stream.
   template <typename ConstBufferSequence>
   std::size_t write_some(implementation_type& impl,
       const ConstBufferSequence& buffers, boost::system::error_code& ec)
   {
     return service_impl_.write_some(impl, buffers, ec);
   }
 
   /// Start an asynchronous write.
   template <typename ConstBufferSequence, typename WriteHandler>
   void async_write_some(implementation_type& impl,
-      const ConstBufferSequence& buffers,
-      BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
+      const ConstBufferSequence& buffers, WriteHandler descriptorr)
   {
-    service_impl_.async_write_some(impl, buffers,
-        BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
+    service_impl_.async_write_some(impl, buffers, descriptorr);
   }
 
   /// 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,
-      const MutableBufferSequence& buffers,
-      BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+      const MutableBufferSequence& buffers, ReadHandler descriptorr)
   {
-    service_impl_.async_read_some(impl, buffers,
-        BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
+    service_impl_.async_read_some(impl, buffers, descriptorr);
   }
 
 private:
-  // Destroy all user-defined handler objects owned by the service.
-  void shutdown_service()
-  {
-    service_impl_.shutdown_service();
-  }
-
   // The platform-specific implementation.
   service_impl_type service_impl_;
 };
 
 } // namespace posix
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // defined(BOOST_ASIO_HAS_POSIX_STREAM_DESCRIPTOR)
        //   || defined(GENERATING_DOCUMENTATION)
 
 #endif // BOOST_ASIO_POSIX_STREAM_DESCRIPTOR_SERVICE_HPP
diff --git a/3rdParty/Boost/src/boost/asio/raw_socket_service.hpp b/3rdParty/Boost/src/boost/asio/raw_socket_service.hpp
index cd8aa04..783c4c2 100644
--- a/3rdParty/Boost/src/boost/asio/raw_socket_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/raw_socket_service.hpp
@@ -1,378 +1,313 @@
 //
 // raw_socket_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_RAW_SOCKET_SERVICE_HPP
 #define BOOST_ASIO_RAW_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>
 #include <cstddef>
 #include <boost/asio/error.hpp>
 #include <boost/asio/io_service.hpp>
 
 #if 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>
 
 namespace boost {
 namespace asio {
 
 /// Default service implementation for a raw socket.
 template <typename Protocol>
 class raw_socket_service
 #if defined(GENERATING_DOCUMENTATION)
   : public boost::asio::io_service::service
 #else
   : public boost::asio::detail::service_base<raw_socket_service<Protocol> >
 #endif
 {
 public:
 #if defined(GENERATING_DOCUMENTATION)
   /// The unique service identifier.
   static boost::asio::io_service::id id;
 #endif
 
   /// The protocol type.
   typedef Protocol protocol_type;
 
   /// The endpoint type.
   typedef typename Protocol::endpoint endpoint_type;
 
 private:
   // The type of the platform-specific implementation.
 #if 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:
   /// The type of a raw socket.
 #if defined(GENERATING_DOCUMENTATION)
   typedef implementation_defined implementation_type;
 #else
   typedef typename service_impl_type::implementation_type implementation_type;
 #endif
 
-  /// (Deprecated: Use native_handle_type.) The native socket type.
-#if defined(GENERATING_DOCUMENTATION)
-  typedef implementation_defined native_type;
-#else
-  typedef typename service_impl_type::native_handle_type native_type;
-#endif
-
   /// The native socket type.
 #if defined(GENERATING_DOCUMENTATION)
-  typedef implementation_defined native_handle_type;
+  typedef implementation_defined native_type;
 #else
-  typedef typename service_impl_type::native_handle_type native_handle_type;
+  typedef typename service_impl_type::native_type native_type;
 #endif
 
   /// Construct a new raw socket service for the specified io_service.
   explicit raw_socket_service(boost::asio::io_service& io_service)
     : boost::asio::detail::service_base<
         raw_socket_service<Protocol> >(io_service),
       service_impl_(io_service)
   {
   }
 
-  /// Construct a new raw socket implementation.
-  void construct(implementation_type& impl)
-  {
-    service_impl_.construct(impl);
-  }
-
-#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
-  /// Move-construct a new raw socket implementation.
-  void move_construct(implementation_type& impl,
-      implementation_type& other_impl)
+  /// Destroy all user-defined handler objects owned by the service.
+  void shutdown_service()
   {
-    service_impl_.move_construct(impl, other_impl);
+    service_impl_.shutdown_service();
   }
 
-  /// Move-assign from another raw socket implementation.
-  void move_assign(implementation_type& impl,
-      raw_socket_service& other_service,
-      implementation_type& other_impl)
+  /// Construct a new raw socket implementation.
+  void construct(implementation_type& impl)
   {
-    service_impl_.move_assign(impl, other_service.service_impl_, other_impl);
+    service_impl_.construct(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)
       service_impl_.open(impl, protocol, ec);
     else
       ec = boost::asio::error::invalid_argument;
     return ec;
   }
 
   /// Assign an existing native socket to a raw socket.
   boost::system::error_code assign(implementation_type& impl,
-      const protocol_type& protocol, const native_handle_type& native_socket,
+      const protocol_type& protocol, const native_type& native_socket,
       boost::system::error_code& ec)
   {
     return service_impl_.assign(impl, protocol, native_socket, ec);
   }
 
   /// Determine whether the socket is open.
   bool is_open(const implementation_type& impl) const
   {
     return service_impl_.is_open(impl);
   }
 
   /// Close a raw socket implementation.
   boost::system::error_code close(implementation_type& impl,
       boost::system::error_code& ec)
   {
     return service_impl_.close(impl, ec);
   }
 
-  /// (Deprecated: Use native_handle().) Get the native socket implementation.
-  native_type native(implementation_type& impl)
-  {
-    return service_impl_.native_handle(impl);
-  }
-
   /// Get the native socket implementation.
-  native_handle_type native_handle(implementation_type& impl)
+  native_type native(implementation_type& impl)
   {
-    return service_impl_.native_handle(impl);
+    return service_impl_.native(impl);
   }
 
   /// Cancel all asynchronous operations associated with the socket.
   boost::system::error_code cancel(implementation_type& impl,
       boost::system::error_code& ec)
   {
     return service_impl_.cancel(impl, ec);
   }
 
   /// Determine whether the socket is at the out-of-band data mark.
   bool at_mark(const implementation_type& impl,
       boost::system::error_code& ec) const
   {
     return service_impl_.at_mark(impl, ec);
   }
 
   /// Determine the number of bytes available for reading.
   std::size_t available(const implementation_type& impl,
       boost::system::error_code& ec) const
   {
     return service_impl_.available(impl, ec);
   }
 
   // Bind the raw socket to the specified local endpoint.
   boost::system::error_code bind(implementation_type& impl,
       const endpoint_type& endpoint, boost::system::error_code& ec)
   {
     return service_impl_.bind(impl, endpoint, ec);
   }
 
   /// Connect the raw socket to the specified endpoint.
   boost::system::error_code connect(implementation_type& impl,
       const endpoint_type& peer_endpoint, boost::system::error_code& ec)
   {
     return service_impl_.connect(impl, peer_endpoint, ec);
   }
 
   /// Start an asynchronous connect.
   template <typename ConnectHandler>
   void async_connect(implementation_type& impl,
-      const endpoint_type& peer_endpoint,
-      BOOST_ASIO_MOVE_ARG(ConnectHandler) handler)
+      const endpoint_type& peer_endpoint, ConnectHandler handler)
   {
-    service_impl_.async_connect(impl, peer_endpoint,
-        BOOST_ASIO_MOVE_CAST(ConnectHandler)(handler));
+    service_impl_.async_connect(impl, peer_endpoint, handler);
   }
 
   /// Set a socket option.
   template <typename SettableSocketOption>
   boost::system::error_code set_option(implementation_type& impl,
       const SettableSocketOption& option, boost::system::error_code& ec)
   {
     return service_impl_.set_option(impl, option, ec);
   }
 
   /// Get a socket option.
   template <typename GettableSocketOption>
   boost::system::error_code get_option(const implementation_type& impl,
       GettableSocketOption& option, boost::system::error_code& ec) const
   {
     return service_impl_.get_option(impl, option, ec);
   }
 
   /// Perform an IO control command on the socket.
   template <typename IoControlCommand>
   boost::system::error_code io_control(implementation_type& impl,
       IoControlCommand& command, boost::system::error_code& ec)
   {
     return service_impl_.io_control(impl, command, ec);
   }
 
-  /// Gets the non-blocking mode of the socket.
-  bool non_blocking(const implementation_type& impl) const
-  {
-    return service_impl_.non_blocking(impl);
-  }
-
-  /// Sets the non-blocking mode of the socket.
-  boost::system::error_code non_blocking(implementation_type& impl,
-      bool mode, boost::system::error_code& ec)
-  {
-    return service_impl_.non_blocking(impl, mode, ec);
-  }
-
-  /// Gets the non-blocking mode of the native socket implementation.
-  bool native_non_blocking(const implementation_type& impl) const
-  {
-    return service_impl_.native_non_blocking(impl);
-  }
-
-  /// Sets the non-blocking mode of the native socket implementation.
-  boost::system::error_code native_non_blocking(implementation_type& impl,
-      bool mode, boost::system::error_code& ec)
-  {
-    return service_impl_.native_non_blocking(impl, mode, ec);
-  }
-
   /// Get the local endpoint.
   endpoint_type local_endpoint(const implementation_type& impl,
       boost::system::error_code& ec) const
   {
     return service_impl_.local_endpoint(impl, ec);
   }
 
   /// Get the remote endpoint.
   endpoint_type remote_endpoint(const implementation_type& impl,
       boost::system::error_code& ec) const
   {
     return service_impl_.remote_endpoint(impl, ec);
   }
 
   /// Disable sends or receives on the socket.
   boost::system::error_code shutdown(implementation_type& impl,
       socket_base::shutdown_type what, boost::system::error_code& ec)
   {
     return service_impl_.shutdown(impl, what, ec);
   }
 
   /// Send the given data to the peer.
   template <typename ConstBufferSequence>
   std::size_t send(implementation_type& impl,
       const ConstBufferSequence& buffers,
       socket_base::message_flags flags, boost::system::error_code& ec)
   {
     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,
-      socket_base::message_flags flags,
-      BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
+      socket_base::message_flags flags, WriteHandler handler)
   {
-    service_impl_.async_send(impl, buffers, flags,
-        BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
+    service_impl_.async_send(impl, buffers, flags, handler);
   }
 
   /// 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,
       socket_base::message_flags flags, boost::system::error_code& ec)
   {
     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,
       const ConstBufferSequence& buffers, const endpoint_type& destination,
-      socket_base::message_flags flags,
-      BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
+      socket_base::message_flags flags, WriteHandler handler)
   {
-    service_impl_.async_send_to(impl, buffers, destination, flags,
-        BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
+    service_impl_.async_send_to(impl, buffers, destination, flags, handler);
   }
 
   /// Receive some data from the peer.
   template <typename MutableBufferSequence>
   std::size_t receive(implementation_type& impl,
       const MutableBufferSequence& buffers,
       socket_base::message_flags flags, boost::system::error_code& ec)
   {
     return service_impl_.receive(impl, buffers, flags, ec);
   }
 
   /// Start an asynchronous receive.
   template <typename MutableBufferSequence, typename ReadHandler>
   void async_receive(implementation_type& impl,
       const MutableBufferSequence& buffers,
-      socket_base::message_flags flags,
-      BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+      socket_base::message_flags flags, ReadHandler handler)
   {
-    service_impl_.async_receive(impl, buffers, flags,
-        BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
+    service_impl_.async_receive(impl, buffers, flags, handler);
   }
 
   /// 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,
       socket_base::message_flags flags, boost::system::error_code& ec)
   {
     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,
       const MutableBufferSequence& buffers, endpoint_type& sender_endpoint,
-      socket_base::message_flags flags,
-      BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+      socket_base::message_flags flags, ReadHandler handler)
   {
     service_impl_.async_receive_from(impl, buffers, sender_endpoint, flags,
-        BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
+        handler);
   }
 
 private:
-  // Destroy all user-defined handler objects owned by the service.
-  void shutdown_service()
-  {
-    service_impl_.shutdown_service();
-  }
-
   // The platform-specific implementation.
   service_impl_type service_impl_;
 };
 
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // BOOST_ASIO_RAW_SOCKET_SERVICE_HPP
diff --git a/3rdParty/Boost/src/boost/asio/read.hpp b/3rdParty/Boost/src/boost/asio/read.hpp
index 937dccd..fd13e75 100644
--- a/3rdParty/Boost/src/boost/asio/read.hpp
+++ b/3rdParty/Boost/src/boost/asio/read.hpp
@@ -1,40 +1,40 @@
 //
 // read.hpp
 // ~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_READ_HPP
 #define BOOST_ASIO_READ_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/basic_streambuf_fwd.hpp>
 #include <boost/asio/error.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 
 /**
  * @defgroup read boost::asio::read
  *
  * @brief Attempt to read a certain amount of data from a stream before
  * returning.
  */
 /*@{*/
 
 /// 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:
  *
@@ -48,110 +48,70 @@ namespace asio {
  *
  * @param s The stream from which the data is to be read. The type must support
  * the SyncReadStream concept.
  *
  * @param buffers One or more buffers into which the data will be read. The sum
  * of the buffer sizes indicates the maximum number of bytes to read from the
  * stream.
  *
  * @returns The number of bytes transferred.
  *
  * @throws boost::system::system_error Thrown on failure.
  *
  * @par Example
  * To read into a single data buffer use the @ref buffer function as follows:
  * @code boost::asio::read(s, boost::asio::buffer(data, size)); @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.
  *
  * @note This overload is equivalent to calling:
  * @code boost::asio::read(
  *     s, buffers,
  *     boost::asio::transfer_all()); @endcode
  */
 template <typename SyncReadStream, typename MutableBufferSequence>
 std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers);
 
 /// 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:
  *
  * @li The supplied buffers are full. 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 stream's
- * read_some function.
- *
- * @param s The stream from which the data is to be read. The type must support
- * the SyncReadStream concept.
- *
- * @param buffers One or more buffers into which the data will be read. The sum
- * of the buffer sizes indicates the maximum number of bytes to read from the
- * stream.
- *
- * @param ec Set to indicate what error occurred, if any.
- *
- * @returns The number of bytes transferred.
- *
- * @par Example
- * To read into a single data buffer use the @ref buffer function as follows:
- * @code boost::asio::read(s, boost::asio::buffer(data, size), ec); @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.
- *
- * @note This overload is equivalent to calling:
- * @code boost::asio::read(
- *     s, buffers,
- *     boost::asio::transfer_all(), ec); @endcode
- */
-template <typename SyncReadStream, typename MutableBufferSequence>
-std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
-    boost::system::error_code& ec);
-
-/// 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:
- *
- * @li The supplied buffers are full. 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 stream's
  * read_some function.
  *
  * @param s The stream from which the data is to be read. The type must support
  * the SyncReadStream concept.
  *
  * @param buffers One or more buffers into which the data will be read. The sum
  * of the buffer sizes indicates the maximum number of bytes to read from the
  * stream.
  *
  * @param completion_condition The function object to be called to determine
  * whether the read operation is complete. The signature of the function object
  * must be:
  * @code std::size_t completion_condition(
  *   // Result of latest read_some operation.
  *   const boost::system::error_code& error,
  *
  *   // Number of bytes transferred so far.
  *   std::size_t bytes_transferred
  * ); @endcode
  * A return value of 0 indicates that the read operation is complete. A non-zero
  * return value indicates the maximum number of bytes to be read on the next
  * call to the stream's read_some function.
  *
  * @returns The number of bytes transferred.
  *
  * @throws boost::system::system_error Thrown on failure.
  *
  * @par Example
  * To read into a single data buffer use the @ref buffer function as follows:
  * @code boost::asio::read(s, boost::asio::buffer(data, size),
  *     boost::asio::transfer_at_least(32)); @endcode
  * See the @ref buffer documentation for information on reading into multiple
@@ -182,171 +142,135 @@ std::size_t read(SyncReadStream& s, const MutableBufferSequence& buffers,
  * @param buffers One or more buffers into which the data will be read. The sum
  * of the buffer sizes indicates the maximum number of bytes to read from the
  * stream.
  *
  * @param completion_condition The function object to be called to determine
  * whether the read operation is complete. The signature of the function object
  * must be:
  * @code std::size_t completion_condition(
  *   // Result of latest read_some operation.
  *   const boost::system::error_code& error,
  *
  *   // Number of bytes transferred so far.
  *   std::size_t bytes_transferred
  * ); @endcode
  * A return value of 0 indicates that the read operation is complete. A non-zero
  * return value indicates the maximum number of bytes to be read on the next
  * call to the stream's read_some function.
  *
  * @param ec Set to indicate what error occurred, if any.
  *
  * @returns The number of bytes read. If an error occurs, returns the total
  * number of bytes successfully transferred prior to the error.
  */
 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)
 
 /// 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:
  *
- * @li The supplied buffer is full (that is, it has reached maximum size).
- *
  * @li An error occurred.
  *
  * This operation is implemented in terms of zero or more calls to the stream's
  * read_some function.
  *
  * @param s The stream from which the data is to be read. The type must support
  * the SyncReadStream concept.
  *
  * @param b The basic_streambuf object into which the data will be read.
  *
  * @returns The number of bytes transferred.
  *
  * @throws boost::system::system_error Thrown on failure.
  *
  * @note This overload is equivalent to calling:
  * @code boost::asio::read(
  *     s, b,
  *     boost::asio::transfer_all()); @endcode
  */
 template <typename SyncReadStream, typename Allocator>
 std::size_t read(SyncReadStream& s, basic_streambuf<Allocator>& b);
 
 /// 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:
  *
- * @li The supplied buffer is full (that is, it has reached maximum size).
- *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the stream's
- * read_some function.
- *
- * @param s The stream from which the data is to be read. The type must support
- * the SyncReadStream concept.
- *
- * @param b The basic_streambuf object into which the data will be read.
- *
- * @param ec Set to indicate what error occurred, if any.
- *
- * @returns The number of bytes transferred.
- *
- * @note This overload is equivalent to calling:
- * @code boost::asio::read(
- *     s, b,
- *     boost::asio::transfer_all(), ec); @endcode
- */
-template <typename SyncReadStream, typename Allocator>
-std::size_t read(SyncReadStream& s, basic_streambuf<Allocator>& b,
-    boost::system::error_code& ec);
-
-/// 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:
- *
- * @li The supplied buffer is full (that is, it has reached maximum size).
- *
  * @li The completion_condition function object returns 0.
  *
  * This operation is implemented in terms of zero or more calls to the stream's
  * read_some function.
  *
  * @param s The stream from which the data is to be read. The type must support
  * the SyncReadStream concept.
  *
  * @param b The basic_streambuf object into which the data will be read.
  *
  * @param completion_condition The function object to be called to determine
  * whether the read operation is complete. The signature of the function object
  * must be:
  * @code std::size_t completion_condition(
  *   // Result of latest read_some operation.
  *   const boost::system::error_code& error,
  *
  *   // Number of bytes transferred so far.
  *   std::size_t bytes_transferred
  * ); @endcode
  * A return value of 0 indicates that the read operation is complete. A non-zero
  * return value indicates the maximum number of bytes to be read on the next
  * call to the stream's read_some function.
  *
  * @returns The number of bytes transferred.
  *
  * @throws boost::system::system_error Thrown on failure.
  */
 template <typename SyncReadStream, typename Allocator,
     typename CompletionCondition>
 std::size_t read(SyncReadStream& s, basic_streambuf<Allocator>& b,
     CompletionCondition completion_condition);
 
 /// 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:
  *
- * @li The supplied buffer is full (that is, it has reached maximum size).
- *
  * @li The completion_condition function object returns 0.
  *
  * This operation is implemented in terms of zero or more calls to the stream's
  * read_some function.
  *
  * @param s The stream from which the data is to be read. The type must support
  * the SyncReadStream concept.
  *
  * @param b The basic_streambuf object into which the data will be read.
  *
  * @param completion_condition The function object to be called to determine
  * whether the read operation is complete. The signature of the function object
  * must be:
  * @code std::size_t completion_condition(
  *   // Result of latest read_some operation.
  *   const boost::system::error_code& error,
  *
  *   // Number of bytes transferred so far.
  *   std::size_t bytes_transferred
  * ); @endcode
  * A return value of 0 indicates that the read operation is complete. A non-zero
  * return value indicates the maximum number of bytes to be read on the next
  * call to the stream's read_some function.
  *
  * @param ec Set to indicate what error occurred, if any.
  *
  * @returns The number of bytes read. If an error occurs, returns the total
  * number of bytes successfully transferred prior to the error.
  */
 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)
@@ -391,234 +315,228 @@ std::size_t read(SyncReadStream& s, basic_streambuf<Allocator>& b,
  * @param handler The handler to be called when the read operation completes.
  * Copies will be made of the handler as required. The function signature of the
  * handler must be:
  * @code void handler(
  *   const boost::system::error_code& error, // Result of operation.
  *
  *   std::size_t bytes_transferred           // Number of bytes copied into the
  *                                           // buffers. If an error occurred,
  *                                           // this will be the  number of
  *                                           // bytes successfully transferred
  *                                           // prior to the error.
  * ); @endcode
  * 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().
  *
  * @par Example
  * To read into a single data buffer use the @ref buffer function as follows:
  * @code
  * boost::asio::async_read(s, boost::asio::buffer(data, size), handler);
  * @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.
  *
  * @note This overload is equivalent to calling:
  * @code boost::asio::async_read(
  *     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_MOVE_ARG(ReadHandler) handler);
+    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
  * data from a stream. The function call always returns immediately. The
  * asynchronous operation will continue until one of the following conditions is
  * true:
  *
  * @li The supplied buffers are full. That is, the bytes transferred is equal to
  * the sum of the buffer sizes.
  *
  * @li The completion_condition function object returns 0.
  *
  * @param s The stream from which the data is to be read. The type must support
  * the AsyncReadStream concept.
  *
  * @param buffers One or more buffers into which the data will be read. The sum
  * of the buffer sizes indicates the maximum number of bytes to read from the
  * stream. 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.
  *
  * @param completion_condition The function object to be called to determine
  * whether the read operation is complete. The signature of the function object
  * must be:
  * @code std::size_t completion_condition(
  *   // Result of latest async_read_some operation.
  *   const boost::system::error_code& error,
  *
  *   // Number of bytes transferred so far.
  *   std::size_t bytes_transferred
  * ); @endcode
  * A return value of 0 indicates that the read operation is complete. A non-zero
  * return value indicates the maximum number of bytes to be read on the next
  * call to the stream's async_read_some function.
  *
  * @param handler The handler to be called when the read operation completes.
  * Copies will be made of the handler as required. The function signature of the
  * handler must be:
  * @code void handler(
  *   const boost::system::error_code& error, // Result of operation.
  *
  *   std::size_t bytes_transferred           // Number of bytes copied into the
  *                                           // buffers. If an error occurred,
  *                                           // this will be the  number of
  *                                           // bytes successfully transferred
  *                                           // prior to the error.
  * ); @endcode
  * 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().
  *
  * @par Example
  * To read into a single data buffer use the @ref buffer function as follows:
  * @code boost::asio::async_read(s,
  *     boost::asio::buffer(data, size),
  *     boost::asio::transfer_at_least(32),
  *     handler); @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 AsyncReadStream, typename MutableBufferSequence,
     typename CompletionCondition, typename ReadHandler>
 void async_read(AsyncReadStream& s, const MutableBufferSequence& buffers,
-    CompletionCondition completion_condition,
-    BOOST_ASIO_MOVE_ARG(ReadHandler) handler);
+    CompletionCondition completion_condition, ReadHandler handler);
 
 #if !defined(BOOST_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
  * asynchronous operation will continue until one of the following conditions is
  * true:
  *
- * @li The supplied buffer is full (that is, it has reached maximum size).
- *
  * @li An error occurred.
  *
  * This operation is implemented in terms of zero or more calls to the stream's
  * async_read_some function, and is known as a <em>composed operation</em>. The
  * program must ensure that the stream performs no other read operations (such
  * as async_read, the stream's async_read_some function, or any other composed
  * operations that perform reads) until this operation completes.
  *
  * @param s The stream from which the data is to be read. The type must support
  * the AsyncReadStream concept.
  *
  * @param b A basic_streambuf object into which the data will be read. Ownership
  * of the streambuf is retained by the caller, which must guarantee that it
  * remains valid until the handler is called.
  *
  * @param handler The handler to be called when the read operation completes.
  * Copies will be made of the handler as required. The function signature of the
  * handler must be:
  * @code void handler(
  *   const boost::system::error_code& error, // Result of operation.
  *
  *   std::size_t bytes_transferred           // Number of bytes copied into the
  *                                           // buffers. If an error occurred,
  *                                           // this will be the  number of
  *                                           // bytes successfully transferred
  *                                           // prior to the error.
  * ); @endcode
  * 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().
  *
  * @note This overload is equivalent to calling:
  * @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_MOVE_ARG(ReadHandler) handler);
+    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
  * data from a stream. The function call always returns immediately. The
  * asynchronous operation will continue until one of the following conditions is
  * true:
  *
- * @li The supplied buffer is full (that is, it has reached maximum size).
- *
  * @li The completion_condition function object returns 0.
  *
  * This operation is implemented in terms of zero or more calls to the stream's
  * async_read_some function, and is known as a <em>composed operation</em>. The
  * program must ensure that the stream performs no other read operations (such
  * as async_read, the stream's async_read_some function, or any other composed
  * operations that perform reads) until this operation completes.
  *
  * @param s The stream from which the data is to be read. The type must support
  * the AsyncReadStream concept.
  *
  * @param b A basic_streambuf object into which the data will be read. Ownership
  * of the streambuf is retained by the caller, which must guarantee that it
  * remains valid until the handler is called.
  *
  * @param completion_condition The function object to be called to determine
  * whether the read operation is complete. The signature of the function object
  * must be:
  * @code std::size_t completion_condition(
  *   // Result of latest async_read_some operation.
  *   const boost::system::error_code& error,
  *
  *   // Number of bytes transferred so far.
  *   std::size_t bytes_transferred
  * ); @endcode
  * A return value of 0 indicates that the read operation is complete. A non-zero
  * return value indicates the maximum number of bytes to be read on the next
  * call to the stream's async_read_some function.
  *
  * @param handler The handler to be called when the read operation completes.
  * Copies will be made of the handler as required. The function signature of the
  * handler must be:
  * @code void handler(
  *   const boost::system::error_code& error, // Result of operation.
  *
  *   std::size_t bytes_transferred           // Number of bytes copied into the
  *                                           // buffers. If an error occurred,
  *                                           // this will be the  number of
  *                                           // bytes successfully transferred
  *                                           // prior to the error.
  * ); @endcode
  * 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 AsyncReadStream, typename Allocator,
     typename CompletionCondition, typename ReadHandler>
 void async_read(AsyncReadStream& s, basic_streambuf<Allocator>& b,
-    CompletionCondition completion_condition,
-    BOOST_ASIO_MOVE_ARG(ReadHandler) handler);
+    CompletionCondition completion_condition, ReadHandler handler);
 
 #endif // !defined(BOOST_NO_IOSTREAM)
 
 /*@}*/
 
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #include <boost/asio/impl/read.hpp>
 
 #endif // BOOST_ASIO_READ_HPP
diff --git a/3rdParty/Boost/src/boost/asio/read_at.hpp b/3rdParty/Boost/src/boost/asio/read_at.hpp
index 7eb30e0..1feba6c 100644
--- a/3rdParty/Boost/src/boost/asio/read_at.hpp
+++ b/3rdParty/Boost/src/boost/asio/read_at.hpp
@@ -1,40 +1,40 @@
 //
 // read_at.hpp
 // ~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_READ_AT_HPP
 #define BOOST_ASIO_READ_AT_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/cstdint.hpp>
 #include <boost/asio/basic_streambuf_fwd.hpp>
 #include <boost/asio/error.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 
 /**
  * @defgroup read_at boost::asio::read_at
  *
  * @brief Attempt to read a certain amount of data at the specified offset
  * before returning.
  */
 /*@{*/
 
 /// 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
@@ -56,116 +56,70 @@ namespace asio {
  *
  * @param buffers One or more buffers into which the data will be read. The sum
  * of the buffer sizes indicates the maximum number of bytes to read from the
  * device.
  *
  * @returns The number of bytes transferred.
  *
  * @throws boost::system::system_error Thrown on failure.
  *
  * @par Example
  * To read into a single data buffer use the @ref buffer function as follows:
  * @code boost::asio::read_at(d, 42, boost::asio::buffer(data, size)); @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.
  *
  * @note This overload is equivalent to calling:
  * @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);
 
 /// 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
  * of the following conditions is true:
  *
  * @li The supplied buffers are full. 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
- * read_some_at function.
- *
- * @param d The device from which the data is to be read. The type must support
- * the SyncRandomAccessReadDevice concept.
- *
- * @param offset The offset at which the data will be read.
- *
- * @param buffers One or more buffers into which the data will be read. The sum
- * of the buffer sizes indicates the maximum number of bytes to read from the
- * device.
- *
- * @param ec Set to indicate what error occurred, if any.
- *
- * @returns The number of bytes transferred.
- *
- * @par Example
- * To read into a single data buffer use the @ref buffer function as follows:
- * @code boost::asio::read_at(d, 42,
- *     boost::asio::buffer(data, size), ec); @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.
- *
- * @note This overload is equivalent to calling:
- * @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,
-    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
- * random access device at the specified offset. The call will block until one
- * of the following conditions is true:
- *
- * @li The supplied buffers are full. 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
  * read_some_at function.
  *
  * @param d The device from which the data is to be read. The type must support
  * the SyncRandomAccessReadDevice concept.
  *
  * @param offset The offset at which the data will be read.
  *
  * @param buffers One or more buffers into which the data will be read. The sum
  * of the buffer sizes indicates the maximum number of bytes to read from the
  * device.
  *
  * @param completion_condition The function object to be called to determine
  * whether the read operation is complete. The signature of the function object
  * must be:
  * @code std::size_t completion_condition(
  *   // Result of latest read_some_at operation.
  *   const boost::system::error_code& error,
  *
  *   // Number of bytes transferred so far.
  *   std::size_t bytes_transferred
  * ); @endcode
  * A return value of 0 indicates that the read operation is complete. A non-zero
  * return value indicates the maximum number of bytes to be read on the next
  * call to the device's read_some_at function.
  *
  * @returns The number of bytes transferred.
  *
  * @throws boost::system::system_error Thrown on failure.
  *
  * @par Example
  * To read into a single data buffer use the @ref buffer function as follows:
  * @code boost::asio::read_at(d, 42, boost::asio::buffer(data, size),
@@ -238,103 +192,70 @@ std::size_t read_at(SyncRandomAccessReadDevice& d,
  * random access device at the specified offset. The call will block until one
  * of the following conditions is true:
  *
  * @li An error occurred.
  *
  * This operation is implemented in terms of zero or more calls to the device's
  * read_some_at function.
  *
  * @param d The device from which the data is to be read. The type must support
  * the SyncRandomAccessReadDevice concept.
  *
  * @param offset The offset at which the data will be read.
  *
  * @param b The basic_streambuf object into which the data will be read.
  *
  * @returns The number of bytes transferred.
  *
  * @throws boost::system::system_error Thrown on failure.
  *
  * @note This overload is equivalent to calling:
  * @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);
 
 /// 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
  * of the following conditions is true:
  *
- * @li An error occurred.
- *
- * This operation is implemented in terms of zero or more calls to the device's
- * read_some_at function.
- *
- * @param d The device from which the data is to be read. The type must support
- * the SyncRandomAccessReadDevice concept.
- *
- * @param offset The offset at which the data will be read.
- *
- * @param b The basic_streambuf object into which the data will be read.
- *
- * @param ec Set to indicate what error occurred, if any.
- *
- * @returns The number of bytes transferred.
- *
- * @note This overload is equivalent to calling:
- * @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,
-    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
- * random access device at the specified offset. The call will block until one
- * of the following conditions is true:
- *
  * @li The completion_condition function object returns 0.
  *
  * This operation is implemented in terms of zero or more calls to the device's
  * read_some_at function.
  *
  * @param d The device from which the data is to be read. The type must support
  * the SyncRandomAccessReadDevice concept.
  *
  * @param offset The offset at which the data will be read.
  *
  * @param b The basic_streambuf object into which the data will be read.
  *
  * @param completion_condition The function object to be called to determine
  * whether the read operation is complete. The signature of the function object
  * must be:
  * @code std::size_t completion_condition(
  *   // Result of latest read_some_at operation.
  *   const boost::system::error_code& error,
  *
  *   // Number of bytes transferred so far.
  *   std::size_t bytes_transferred
  * ); @endcode
  * A return value of 0 indicates that the read operation is complete. A non-zero
  * return value indicates the maximum number of bytes to be read on the next
  * call to the device's read_some_at function.
  *
  * @returns The number of bytes transferred.
  *
  * @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,
     CompletionCondition completion_condition);
@@ -424,234 +345,231 @@ std::size_t read_at(SyncRandomAccessReadDevice& d,
  * @param handler The handler to be called when the read operation completes.
  * Copies will be made of the handler as required. The function signature of the
  * handler must be:
  * @code void handler(
  *   // Result of operation.
  *   const boost::system::error_code& error,
  *
  *   // Number of bytes copied into the buffers. If an error
  *   // occurred, this will be the number of bytes successfully
  *   // transferred prior to the error.
  *   std::size_t bytes_transferred
  * ); @endcode
  * 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().
  *
  * @par Example
  * To read into a single data buffer use the @ref buffer function as follows:
  * @code
  * boost::asio::async_read_at(d, 42, boost::asio::buffer(data, size), handler);
  * @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.
  *
  * @note This overload is equivalent to calling:
  * @code boost::asio::async_read_at(
  *     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,
-    const MutableBufferSequence& buffers,
-    BOOST_ASIO_MOVE_ARG(ReadHandler) handler);
+    const MutableBufferSequence& buffers, 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
  * data from a random access device at the specified offset. The function call
  * always returns immediately. The asynchronous operation will continue until
  * one of the following conditions is true:
  *
  * @li The supplied buffers are full. That is, the bytes transferred is equal to
  * the sum of the buffer sizes.
  *
  * @li The completion_condition function object returns 0.
  *
  * @param d The device from which the data is to be read. The type must support
  * the AsyncRandomAccessReadDevice concept.
  *
  * @param offset The offset at which the data will be read.
  *
  * @param buffers One or more buffers into which the data will be read. The sum
  * of the buffer sizes indicates the maximum number of bytes to read from the
  * device. 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.
  *
  * @param completion_condition The function object to be called to determine
  * whether the read operation is complete. The signature of the function object
  * must be:
  * @code std::size_t completion_condition(
  *   // Result of latest async_read_some_at operation.
  *   const boost::system::error_code& error,
  *
  *   // Number of bytes transferred so far.
  *   std::size_t bytes_transferred
  * ); @endcode
  * A return value of 0 indicates that the read operation is complete. A non-zero
  * return value indicates the maximum number of bytes to be read on the next
  * call to the device's async_read_some_at function.
  *
  * @param handler The handler to be called when the read operation completes.
  * Copies will be made of the handler as required. The function signature of the
  * handler must be:
  * @code void handler(
  *   // Result of operation.
  *   const boost::system::error_code& error,
  *
  *   // Number of bytes copied into the buffers. If an error
  *   // occurred, this will be the number of bytes successfully
  *   // transferred prior to the error.
  *   std::size_t bytes_transferred
  * ); @endcode
  * 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().
  *
  * @par Example
  * To read into a single data buffer use the @ref buffer function as follows:
  * @code boost::asio::async_read_at(d, 42,
  *     boost::asio::buffer(data, size),
  *     boost::asio::transfer_at_least(32),
  *     handler); @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 AsyncRandomAccessReadDevice, typename MutableBufferSequence,
     typename CompletionCondition, typename ReadHandler>
 void async_read_at(AsyncRandomAccessReadDevice& d,
     boost::uint64_t offset, const MutableBufferSequence& buffers,
-    CompletionCondition completion_condition,
-    BOOST_ASIO_MOVE_ARG(ReadHandler) handler);
+    CompletionCondition completion_condition, ReadHandler handler);
 
 #if !defined(BOOST_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
  * always returns immediately. The asynchronous operation will continue until
  * one of the following conditions is true:
  *
  * @li An error occurred.
  *
  * This operation is implemented in terms of zero or more calls to the device's
  * async_read_some_at function.
  *
  * @param d The device from which the data is to be read. The type must support
  * the AsyncRandomAccessReadDevice concept.
  *
  * @param offset The offset at which the data will be read.
  *
  * @param b A basic_streambuf object into which the data will be read. Ownership
  * of the streambuf is retained by the caller, which must guarantee that it
  * remains valid until the handler is called.
  *
  * @param handler The handler to be called when the read operation completes.
  * Copies will be made of the handler as required. The function signature of the
  * handler must be:
  * @code void handler(
  *   // Result of operation.
  *   const boost::system::error_code& error,
  *
  *   // Number of bytes copied into the buffers. If an error
  *   // occurred, this will be the number of bytes successfully
  *   // transferred prior to the error.
  *   std::size_t bytes_transferred
  * ); @endcode
  * 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().
  *
  * @note This overload is equivalent to calling:
  * @code boost::asio::async_read_at(
  *     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,
-    basic_streambuf<Allocator>& b, BOOST_ASIO_MOVE_ARG(ReadHandler) handler);
+    basic_streambuf<Allocator>& b, 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
  * data from a random access device at the specified offset. The function call
  * always returns immediately. The asynchronous operation will continue until
  * one of the following conditions is true:
  *
  * @li The completion_condition function object returns 0.
  *
  * This operation is implemented in terms of zero or more calls to the device's
  * async_read_some_at function.
  *
  * @param d The device from which the data is to be read. The type must support
  * the AsyncRandomAccessReadDevice concept.
  *
  * @param offset The offset at which the data will be read.
  *
  * @param b A basic_streambuf object into which the data will be read. Ownership
  * of the streambuf is retained by the caller, which must guarantee that it
  * remains valid until the handler is called.
  *
  * @param completion_condition The function object to be called to determine
  * whether the read operation is complete. The signature of the function object
  * must be:
  * @code std::size_t completion_condition(
  *   // Result of latest async_read_some_at operation.
  *   const boost::system::error_code& error,
  *
  *   // Number of bytes transferred so far.
  *   std::size_t bytes_transferred
  * ); @endcode
  * A return value of 0 indicates that the read operation is complete. A non-zero
  * return value indicates the maximum number of bytes to be read on the next
  * call to the device's async_read_some_at function.
  *
  * @param handler The handler to be called when the read operation completes.
  * Copies will be made of the handler as required. The function signature of the
  * handler must be:
  * @code void handler(
  *   // Result of operation.
  *   const boost::system::error_code& error,
  *
  *   // Number of bytes copied into the buffers. If an error
  *   // occurred, this will be the number of bytes successfully
  *   // transferred prior to the error.
  *   std::size_t bytes_transferred
  * ); @endcode
  * 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 AsyncRandomAccessReadDevice, typename Allocator,
     typename CompletionCondition, typename ReadHandler>
 void async_read_at(AsyncRandomAccessReadDevice& d,
     boost::uint64_t offset, basic_streambuf<Allocator>& b,
-    CompletionCondition completion_condition,
-    BOOST_ASIO_MOVE_ARG(ReadHandler) handler);
+    CompletionCondition completion_condition, ReadHandler handler);
 
 #endif // !defined(BOOST_NO_IOSTREAM)
 
 /*@}*/
 
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #include <boost/asio/impl/read_at.hpp>
 
 #endif // BOOST_ASIO_READ_AT_HPP
diff --git a/3rdParty/Boost/src/boost/asio/read_until.hpp b/3rdParty/Boost/src/boost/asio/read_until.hpp
index 1f1bddb..546537b 100644
--- a/3rdParty/Boost/src/boost/asio/read_until.hpp
+++ b/3rdParty/Boost/src/boost/asio/read_until.hpp
@@ -1,83 +1,97 @@
 //
 // read_until.hpp
 // ~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_READ_UNTIL_HPP
 #define BOOST_ASIO_READ_UNTIL_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_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/basic_streambuf.hpp>
 #include <boost/asio/detail/regex_fwd.hpp>
 #include <boost/asio/error.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 
 namespace detail
 {
-  char (&has_result_type_helper(...))[2];
-
+#if BOOST_WORKAROUND(__CODEGEARC__, BOOST_TESTED_AT(0x610))
   template <typename T>
-  char has_result_type_helper(T*, typename T::result_type* = 0);
-
+  struct has_result_type
+  {
+    template <typename U> struct inner
+    {
+        struct big { char a[100]; };
+        static big helper(U, ...);
+        static char helper(U, typename U::result_type* = 0);
+    };
+    static const T& ref();
+    enum { value = (sizeof((inner<const T&>::helper)((ref)())) == 1) };
+  };
+#else // BOOST_WORKAROUND(__CODEGEARC__, BOOST_TESTED_AT(0x610))
   template <typename T>
   struct has_result_type
   {
-    enum { value = (sizeof((has_result_type_helper)((T*)(0))) == 1) };
+    struct big { char a[100]; };
+    template <typename U> static big helper(U, ...);
+    template <typename U> static char helper(U, typename U::result_type* = 0);
+    static const T& ref();
+    enum { value = (sizeof((helper)((ref)())) == 1) };
   };
+#endif // BOOST_WORKAROUND(__CODEGEARC__, BOOST_TESTED_AT(0x610))
 } // namespace detail
 
 /// Type trait used to determine whether a type can be used as a match condition
 /// function with read_until and async_read_until.
 template <typename T>
 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
       || detail::has_result_type<T>::value
   };
 #endif
 };
 
 /**
  * @defgroup read_until boost::asio::read_until
  *
  * @brief Read data into a streambuf until it contains a delimiter, matches a
  * regular expression, or a function object indicates a match.
  */
 /*@{*/
 
 /// Read data into a streambuf until it contains a specified delimiter.
 /**
  * This function is used to read data into the specified streambuf until the
  * streambuf's get area contains the specified delimiter. The call will block
  * until one of the following conditions is true:
  *
  * @li The get area of the streambuf contains the specified delimiter.
  *
@@ -558,71 +572,71 @@ std::size_t read_until(SyncReadStream& s,
  * @note After a successful async_read_until operation, the streambuf may
  * contain additional data beyond the delimiter. An application will typically
  * leave that data in the streambuf for a subsequent async_read_until operation
  * to examine.
  *
  * @par Example
  * To asynchronously read data into a streambuf until a newline is encountered:
  * @code boost::asio::streambuf b;
  * ...
  * void handler(const boost::system::error_code& e, std::size_t size)
  * {
  *   if (!e)
  *   {
  *     std::istream is(&b);
  *     std::string line;
  *     std::getline(is, line);
  *     ...
  *   }
  * }
  * ...
  * boost::asio::async_read_until(s, b, '\n', handler); @endcode
  * After the @c async_read_until operation completes successfully, the buffer
  * @c b contains the delimiter:
  * @code { 'a', 'b', ..., 'c', '\n', 'd', 'e', ... } @endcode
  * The call to @c std::getline then extracts the data up to and including the
  * delimiter, so that the string @c line contains:
  * @code { 'a', 'b', ..., 'c', '\n' } @endcode
  * 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::basic_streambuf<Allocator>& b,
-    char delim, BOOST_ASIO_MOVE_ARG(ReadHandler) handler);
+    char delim, ReadHandler handler);
 
 /// Start an asynchronous operation to read data into a streambuf until it
 /// contains a specified delimiter.
 /**
  * This function is used to asynchronously read data into the specified
  * streambuf until the streambuf's get area contains the specified delimiter.
  * The function call always returns immediately. The asynchronous operation
  * will continue until one of the following conditions is true:
  *
  * @li The get area of the streambuf contains the specified delimiter.
  *
  * @li An error occurred.
  *
  * This operation is implemented in terms of zero or more calls to the stream's
  * async_read_some function, and is known as a <em>composed operation</em>. If
  * the streambuf's get area already contains the delimiter, this asynchronous
  * operation completes immediately. The program must ensure that the stream
  * performs no other read operations (such as async_read, async_read_until, the
  * stream's async_read_some function, or any other composed operations that
  * perform reads) until this operation completes.
  *
  * @param s The stream from which the data is to be read. The type must support
  * the AsyncReadStream concept.
  *
  * @param b A streambuf object into which the data will be read. Ownership of
  * the streambuf is retained by the caller, which must guarantee that it remains
  * valid until the handler is called.
  *
  * @param delim The delimiter string.
  *
  * @param handler The handler to be called when the read operation completes.
  * Copies will be made of the handler as required. The function signature of the
  * handler must be:
  * @code void handler(
  *   // Result of operation.
@@ -641,71 +655,71 @@ void async_read_until(AsyncReadStream& s,
  * @note After a successful async_read_until operation, the streambuf may
  * contain additional data beyond the delimiter. An application will typically
  * leave that data in the streambuf for a subsequent async_read_until operation
  * to examine.
  *
  * @par Example
  * To asynchronously read data into a streambuf until a newline is encountered:
  * @code boost::asio::streambuf b;
  * ...
  * void handler(const boost::system::error_code& e, std::size_t size)
  * {
  *   if (!e)
  *   {
  *     std::istream is(&b);
  *     std::string line;
  *     std::getline(is, line);
  *     ...
  *   }
  * }
  * ...
  * boost::asio::async_read_until(s, b, "\r\n", handler); @endcode
  * After the @c async_read_until operation completes successfully, the buffer
  * @c b contains the delimiter:
  * @code { 'a', 'b', ..., 'c', '\r', '\n', 'd', 'e', ... } @endcode
  * The call to @c std::getline then extracts the data up to and including the
  * delimiter, so that the string @c line contains:
  * @code { 'a', 'b', ..., 'c', '\r', '\n' } @endcode
  * 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::basic_streambuf<Allocator>& b, const std::string& delim,
-    BOOST_ASIO_MOVE_ARG(ReadHandler) handler);
+    ReadHandler handler);
 
 /// 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
  * asynchronous operation will continue until one of the following conditions
  * is true:
  *
  * @li A substring of the streambuf's get area matches the regular expression.
  *
  * @li An error occurred.
  *
  * This operation is implemented in terms of zero or more calls to the stream's
  * async_read_some function, and is known as a <em>composed operation</em>. If
  * the streambuf's get area already contains data that matches the regular
  * expression, this asynchronous operation completes immediately. The program
  * must ensure that the stream performs no other read operations (such as
  * async_read, async_read_until, the stream's async_read_some function, or any
  * other composed operations that perform reads) until this operation
  * completes.
  *
  * @param s The stream from which the data is to be read. The type must support
  * the AsyncReadStream concept.
  *
  * @param b A streambuf object into which the data will be read. Ownership of
  * the streambuf is retained by the caller, which must guarantee that it remains
  * valid until the handler is called.
  *
  * @param expr The regular expression.
  *
  * @param handler The handler to be called when the read operation completes.
  * Copies will be made of the handler as required. The function signature of the
  * handler must be:
@@ -728,71 +742,71 @@ void async_read_until(AsyncReadStream& s,
  * contain additional data beyond that which matched the regular expression. An
  * application will typically leave that data in the streambuf for a subsequent
  * async_read_until operation to examine.
  *
  * @par Example
  * To asynchronously read data into a streambuf until a CR-LF sequence is
  * encountered:
  * @code boost::asio::streambuf b;
  * ...
  * void handler(const boost::system::error_code& e, std::size_t size)
  * {
  *   if (!e)
  *   {
  *     std::istream is(&b);
  *     std::string line;
  *     std::getline(is, line);
  *     ...
  *   }
  * }
  * ...
  * boost::asio::async_read_until(s, b, boost::regex("\r\n"), handler); @endcode
  * After the @c async_read_until operation completes successfully, the buffer
  * @c b contains the data which matched the regular expression:
  * @code { 'a', 'b', ..., 'c', '\r', '\n', 'd', 'e', ... } @endcode
  * The call to @c std::getline then extracts the data up to and including the
  * match, so that the string @c line contains:
  * @code { 'a', 'b', ..., 'c', '\r', '\n' } @endcode
  * 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::basic_streambuf<Allocator>& b, const boost::regex& expr,
-    BOOST_ASIO_MOVE_ARG(ReadHandler) handler);
+    ReadHandler handler);
 
 /// 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
  * function call always returns immediately. The asynchronous operation will
  * continue until one of the following conditions is true:
  *
  * @li The match condition function object returns a std::pair where the second
  * element evaluates to true.
  *
  * @li An error occurred.
  *
  * This operation is implemented in terms of zero or more calls to the stream's
  * async_read_some function, and is known as a <em>composed operation</em>. If
  * the match condition function object already indicates a match, this
  * asynchronous operation completes immediately. The program must ensure that
  * the stream performs no other read operations (such as async_read,
  * async_read_until, the stream's async_read_some function, or any other
  * composed operations that perform reads) until this operation completes.
  *
  * @param s The stream from which the data is to be read. The type must support
  * the AsyncReadStream concept.
  *
  * @param b A streambuf object into which the data will be read.
  *
  * @param match_condition The function object to be called to determine whether
  * a match exists. The signature of the function object must be:
  * @code pair<iterator, bool> match_condition(iterator begin, iterator end);
  * @endcode
  * where @c iterator represents the type:
  * @code buffers_iterator<basic_streambuf<Allocator>::const_buffers_type>
  * @endcode
@@ -857,50 +871,50 @@ void async_read_until(AsyncReadStream& s,
  * @code class match_char
  * {
  * public:
  *   explicit match_char(char c) : c_(c) {}
  *
  *   template <typename Iterator>
  *   std::pair<Iterator, bool> operator()(
  *       Iterator begin, Iterator end) const
  *   {
  *     Iterator i = begin;
  *     while (i != end)
  *       if (c_ == *i++)
  *         return std::make_pair(i, true);
  *     return std::make_pair(i, false);
  *   }
  *
  * private:
  *   char c_;
  * };
  *
  * namespace asio {
  *   template <> struct is_match_condition<match_char>
  *     : public boost::true_type {};
  * } // namespace asio
  * ...
  * void handler(const boost::system::error_code& e, std::size_t size);
  * ...
  * 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::basic_streambuf<Allocator>& b,
-    MatchCondition match_condition, BOOST_ASIO_MOVE_ARG(ReadHandler) handler,
+    MatchCondition match_condition, ReadHandler handler,
     typename boost::enable_if<is_match_condition<MatchCondition> >::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 // 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
deleted file mode 100644
index edd1593..0000000
--- a/3rdParty/Boost/src/boost/asio/seq_packet_socket_service.hpp
+++ /dev/null
@@ -1,341 +0,0 @@
-//
-// seq_packet_socket_service.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_SEQ_PACKET_SOCKET_SERVICE_HPP
-#define BOOST_ASIO_SEQ_PACKET_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>
-#include <cstddef>
-#include <boost/asio/error.hpp>
-#include <boost/asio/io_service.hpp>
-
-#if 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>
-
-namespace boost {
-namespace asio {
-
-/// Default service implementation for a sequenced packet socket.
-template <typename Protocol>
-class seq_packet_socket_service
-#if defined(GENERATING_DOCUMENTATION)
-  : public boost::asio::io_service::service
-#else
-  : public boost::asio::detail::service_base<
-      seq_packet_socket_service<Protocol> >
-#endif
-{
-public:
-#if defined(GENERATING_DOCUMENTATION)
-  /// The unique service identifier.
-  static boost::asio::io_service::id id;
-#endif
-
-  /// The protocol type.
-  typedef Protocol protocol_type;
-
-  /// The endpoint type.
-  typedef typename Protocol::endpoint endpoint_type;
-
-private:
-  // The type of the platform-specific implementation.
-#if 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:
-  /// The type of a sequenced packet socket implementation.
-#if defined(GENERATING_DOCUMENTATION)
-  typedef implementation_defined implementation_type;
-#else
-  typedef typename service_impl_type::implementation_type implementation_type;
-#endif
-
-  /// (Deprecated: Use native_handle_type.) The native socket type.
-#if defined(GENERATING_DOCUMENTATION)
-  typedef implementation_defined native_type;
-#else
-  typedef typename service_impl_type::native_handle_type native_type;
-#endif
-
-  /// The native socket type.
-#if defined(GENERATING_DOCUMENTATION)
-  typedef implementation_defined native_handle_type;
-#else
-  typedef typename service_impl_type::native_handle_type native_handle_type;
-#endif
-
-  /// Construct a new sequenced packet socket service for the specified
-  /// io_service.
-  explicit seq_packet_socket_service(boost::asio::io_service& io_service)
-    : boost::asio::detail::service_base<
-        seq_packet_socket_service<Protocol> >(io_service),
-      service_impl_(io_service)
-  {
-  }
-
-  /// Construct a new sequenced packet socket implementation.
-  void construct(implementation_type& impl)
-  {
-    service_impl_.construct(impl);
-  }
-
-#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
-  /// Move-construct a new sequenced packet socket implementation.
-  void move_construct(implementation_type& impl,
-      implementation_type& other_impl)
-  {
-    service_impl_.move_construct(impl, other_impl);
-  }
-
-  /// Move-assign from another sequenced packet socket implementation.
-  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);
-  }
-#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)
-      service_impl_.open(impl, protocol, ec);
-    else
-      ec = boost::asio::error::invalid_argument;
-    return ec;
-  }
-
-  /// Assign an existing native socket to a sequenced packet socket.
-  boost::system::error_code assign(implementation_type& impl,
-      const protocol_type& protocol, const native_handle_type& native_socket,
-      boost::system::error_code& ec)
-  {
-    return service_impl_.assign(impl, protocol, native_socket, ec);
-  }
-
-  /// Determine whether the socket is open.
-  bool is_open(const implementation_type& impl) const
-  {
-    return service_impl_.is_open(impl);
-  }
-
-  /// Close a sequenced packet socket implementation.
-  boost::system::error_code close(implementation_type& impl,
-      boost::system::error_code& ec)
-  {
-    return service_impl_.close(impl, ec);
-  }
-
-  /// (Deprecated: Use native_handle().) Get the native socket implementation.
-  native_type native(implementation_type& impl)
-  {
-    return service_impl_.native_handle(impl);
-  }
-
-  /// Get the native socket implementation.
-  native_handle_type native_handle(implementation_type& impl)
-  {
-    return service_impl_.native_handle(impl);
-  }
-
-  /// Cancel all asynchronous operations associated with the socket.
-  boost::system::error_code cancel(implementation_type& impl,
-      boost::system::error_code& ec)
-  {
-    return service_impl_.cancel(impl, ec);
-  }
-
-  /// Determine whether the socket is at the out-of-band data mark.
-  bool at_mark(const implementation_type& impl,
-      boost::system::error_code& ec) const
-  {
-    return service_impl_.at_mark(impl, ec);
-  }
-
-  /// Determine the number of bytes available for reading.
-  std::size_t available(const implementation_type& impl,
-      boost::system::error_code& ec) const
-  {
-    return service_impl_.available(impl, ec);
-  }
-
-  /// Bind the sequenced packet socket to the specified local endpoint.
-  boost::system::error_code bind(implementation_type& impl,
-      const endpoint_type& endpoint, boost::system::error_code& ec)
-  {
-    return service_impl_.bind(impl, endpoint, ec);
-  }
-
-  /// Connect the sequenced packet socket to the specified endpoint.
-  boost::system::error_code connect(implementation_type& impl,
-      const endpoint_type& peer_endpoint, boost::system::error_code& ec)
-  {
-    return service_impl_.connect(impl, peer_endpoint, ec);
-  }
-
-  /// Start an asynchronous connect.
-  template <typename ConnectHandler>
-  void async_connect(implementation_type& impl,
-      const endpoint_type& peer_endpoint,
-      BOOST_ASIO_MOVE_ARG(ConnectHandler) handler)
-  {
-    service_impl_.async_connect(impl, peer_endpoint,
-        BOOST_ASIO_MOVE_CAST(ConnectHandler)(handler));
-  }
-
-  /// Set a socket option.
-  template <typename SettableSocketOption>
-  boost::system::error_code set_option(implementation_type& impl,
-      const SettableSocketOption& option, boost::system::error_code& ec)
-  {
-    return service_impl_.set_option(impl, option, ec);
-  }
-
-  /// Get a socket option.
-  template <typename GettableSocketOption>
-  boost::system::error_code get_option(const implementation_type& impl,
-      GettableSocketOption& option, boost::system::error_code& ec) const
-  {
-    return service_impl_.get_option(impl, option, ec);
-  }
-
-  /// Perform an IO control command on the socket.
-  template <typename IoControlCommand>
-  boost::system::error_code io_control(implementation_type& impl,
-      IoControlCommand& command, boost::system::error_code& ec)
-  {
-    return service_impl_.io_control(impl, command, ec);
-  }
-
-  /// Gets the non-blocking mode of the socket.
-  bool non_blocking(const implementation_type& impl) const
-  {
-    return service_impl_.non_blocking(impl);
-  }
-
-  /// Sets the non-blocking mode of the socket.
-  boost::system::error_code non_blocking(implementation_type& impl,
-      bool mode, boost::system::error_code& ec)
-  {
-    return service_impl_.non_blocking(impl, mode, ec);
-  }
-
-  /// Gets the non-blocking mode of the native socket implementation.
-  bool native_non_blocking(const implementation_type& impl) const
-  {
-    return service_impl_.native_non_blocking(impl);
-  }
-
-  /// Sets the non-blocking mode of the native socket implementation.
-  boost::system::error_code native_non_blocking(implementation_type& impl,
-      bool mode, boost::system::error_code& ec)
-  {
-    return service_impl_.native_non_blocking(impl, mode, ec);
-  }
-
-  /// Get the local endpoint.
-  endpoint_type local_endpoint(const implementation_type& impl,
-      boost::system::error_code& ec) const
-  {
-    return service_impl_.local_endpoint(impl, ec);
-  }
-
-  /// Get the remote endpoint.
-  endpoint_type remote_endpoint(const implementation_type& impl,
-      boost::system::error_code& ec) const
-  {
-    return service_impl_.remote_endpoint(impl, ec);
-  }
-
-  /// Disable sends or receives on the socket.
-  boost::system::error_code shutdown(implementation_type& impl,
-      socket_base::shutdown_type what, boost::system::error_code& ec)
-  {
-    return service_impl_.shutdown(impl, what, ec);
-  }
-
-  /// Send the given data to the peer.
-  template <typename ConstBufferSequence>
-  std::size_t send(implementation_type& impl,
-      const ConstBufferSequence& buffers,
-      socket_base::message_flags flags, boost::system::error_code& ec)
-  {
-    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,
-      socket_base::message_flags flags,
-      BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
-  {
-    service_impl_.async_send(impl, buffers, flags,
-        BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
-  }
-
-  /// 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,
-      socket_base::message_flags& out_flags, boost::system::error_code& ec)
-  {
-    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,
-      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));
-  }
-
-private:
-  // Destroy all user-defined handler objects owned by the service.
-  void shutdown_service()
-  {
-    service_impl_.shutdown_service();
-  }
-
-  // The platform-specific implementation.
-  service_impl_type service_impl_;
-};
-
-} // namespace asio
-} // namespace boost
-
-#include <boost/asio/detail/pop_options.hpp>
-
-#endif // BOOST_ASIO_SEQ_PACKET_SOCKET_SERVICE_HPP
diff --git a/3rdParty/Boost/src/boost/asio/serial_port.hpp b/3rdParty/Boost/src/boost/asio/serial_port.hpp
index 58d6b78..a2f1721 100644
--- a/3rdParty/Boost/src/boost/asio/serial_port.hpp
+++ b/3rdParty/Boost/src/boost/asio/serial_port.hpp
@@ -1,38 +1,38 @@
 //
 // serial_port.hpp
 // ~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2011 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)
 //
 
 #ifndef BOOST_ASIO_SERIAL_PORT_HPP
 #define BOOST_ASIO_SERIAL_PORT_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_SERIAL_PORT) \
   || defined(GENERATING_DOCUMENTATION)
 
 #include <boost/asio/basic_serial_port.hpp>
 
 namespace boost {
 namespace asio {
 
 /// Typedef for the typical usage of a serial port.
 typedef basic_serial_port<> serial_port;
 
 } // namespace asio
 } // namespace boost
 
 #endif // defined(BOOST_ASIO_HAS_SERIAL_PORT)
        //   || defined(GENERATING_DOCUMENTATION)
 
 #endif // BOOST_ASIO_SERIAL_PORT_HPP
diff --git a/3rdParty/Boost/src/boost/asio/serial_port_base.hpp b/3rdParty/Boost/src/boost/asio/serial_port_base.hpp
index f14ba02..083d006 100644
--- a/3rdParty/Boost/src/boost/asio/serial_port_base.hpp
+++ b/3rdParty/Boost/src/boost/asio/serial_port_base.hpp
@@ -1,40 +1,40 @@
 //
 // serial_port_base.hpp
 // ~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2011 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)
 //
 
 #ifndef BOOST_ASIO_SERIAL_PORT_BASE_HPP
 #define BOOST_ASIO_SERIAL_PORT_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_HAS_SERIAL_PORT) \
   || defined(GENERATING_DOCUMENTATION)
 
 #if !defined(BOOST_WINDOWS) && !defined(__CYGWIN__)
 # include <termios.h>
 #endif // !defined(BOOST_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__)
 # define BOOST_ASIO_OPTION_STORAGE DCB
 #else
 # define BOOST_ASIO_OPTION_STORAGE termios
 #endif
 
 #include <boost/asio/detail/push_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..1a8a11b 100644
--- a/3rdParty/Boost/src/boost/asio/serial_port_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/serial_port_service.hpp
@@ -1,240 +1,206 @@
 //
 // serial_port_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_SERIAL_PORT_SERVICE_HPP
 #define BOOST_ASIO_SERIAL_PORT_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_HAS_SERIAL_PORT) \
   || defined(GENERATING_DOCUMENTATION)
 
 #include <cstddef>
 #include <string>
 #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>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 
 /// Default service implementation for a serial port.
 class serial_port_service
 #if defined(GENERATING_DOCUMENTATION)
   : public boost::asio::io_service::service
 #else
   : public boost::asio::detail::service_base<serial_port_service>
 #endif
 {
 public:
 #if defined(GENERATING_DOCUMENTATION)
   /// The unique service identifier.
   static boost::asio::io_service::id id;
 #endif
 
 private:
   // The type of the platform-specific implementation.
 #if defined(BOOST_ASIO_HAS_IOCP)
   typedef detail::win_iocp_serial_port_service service_impl_type;
 #else
   typedef detail::reactive_serial_port_service service_impl_type;
 #endif
 
 public:
   /// The type of a serial port implementation.
 #if defined(GENERATING_DOCUMENTATION)
   typedef implementation_defined implementation_type;
 #else
   typedef service_impl_type::implementation_type implementation_type;
 #endif
 
-  /// (Deprecated: Use native_handle_type.) The native handle type.
-#if defined(GENERATING_DOCUMENTATION)
-  typedef implementation_defined native_type;
-#else
-  typedef service_impl_type::native_handle_type native_type;
-#endif
-
   /// The native handle type.
 #if defined(GENERATING_DOCUMENTATION)
-  typedef implementation_defined native_handle_type;
+  typedef implementation_defined native_type;
 #else
-  typedef service_impl_type::native_handle_type native_handle_type;
+  typedef service_impl_type::native_type native_type;
 #endif
 
   /// Construct a new serial port service for the specified io_service.
   explicit serial_port_service(boost::asio::io_service& io_service)
     : boost::asio::detail::service_base<serial_port_service>(io_service),
       service_impl_(io_service)
   {
   }
 
-  /// Construct a new serial port implementation.
-  void construct(implementation_type& impl)
-  {
-    service_impl_.construct(impl);
-  }
-
-#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
-  /// Move-construct a new serial port implementation.
-  void move_construct(implementation_type& impl,
-      implementation_type& other_impl)
+  /// Destroy all user-defined handler objects owned by the service.
+  void shutdown_service()
   {
-    service_impl_.move_construct(impl, other_impl);
+    service_impl_.shutdown_service();
   }
 
-  /// Move-assign from another serial port implementation.
-  void move_assign(implementation_type& impl,
-      serial_port_service& other_service,
-      implementation_type& other_impl)
+  /// Construct a new serial port implementation.
+  void construct(implementation_type& impl)
   {
-    service_impl_.move_assign(impl, other_service.service_impl_, other_impl);
+    service_impl_.construct(impl);
   }
-#endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
 
   /// Destroy a serial port implementation.
   void destroy(implementation_type& impl)
   {
     service_impl_.destroy(impl);
   }
 
   /// Open a serial port.
   boost::system::error_code open(implementation_type& impl,
       const std::string& device, boost::system::error_code& ec)
   {
     return service_impl_.open(impl, device, ec);
   }
 
   /// Assign an existing native handle to a serial port.
   boost::system::error_code assign(implementation_type& impl,
-      const native_handle_type& handle, boost::system::error_code& ec)
+      const native_type& native_handle, boost::system::error_code& ec)
   {
-    return service_impl_.assign(impl, handle, ec);
+    return service_impl_.assign(impl, native_handle, ec);
   }
 
   /// Determine whether the handle is open.
   bool is_open(const implementation_type& impl) const
   {
     return service_impl_.is_open(impl);
   }
 
   /// Close a serial port implementation.
   boost::system::error_code close(implementation_type& impl,
       boost::system::error_code& ec)
   {
     return service_impl_.close(impl, ec);
   }
 
-  /// (Deprecated: Use native_handle().) Get the native handle implementation.
-  native_type native(implementation_type& impl)
-  {
-    return service_impl_.native_handle(impl);
-  }
-
   /// Get the native handle implementation.
-  native_handle_type native_handle(implementation_type& impl)
+  native_type native(implementation_type& impl)
   {
-    return service_impl_.native_handle(impl);
+    return service_impl_.native(impl);
   }
 
   /// Cancel all asynchronous operations associated with the handle.
   boost::system::error_code cancel(implementation_type& impl,
       boost::system::error_code& ec)
   {
     return service_impl_.cancel(impl, ec);
   }
 
   /// Set a serial port option.
   template <typename SettableSerialPortOption>
   boost::system::error_code set_option(implementation_type& impl,
       const SettableSerialPortOption& option, boost::system::error_code& ec)
   {
     return service_impl_.set_option(impl, option, ec);
   }
 
   /// Get a serial port option.
   template <typename GettableSerialPortOption>
   boost::system::error_code get_option(const implementation_type& impl,
       GettableSerialPortOption& option, boost::system::error_code& ec) const
   {
     return service_impl_.get_option(impl, option, ec);
   }
 
   /// Send a break sequence to the serial port.
   boost::system::error_code send_break(implementation_type& impl,
       boost::system::error_code& ec)
   {
     return service_impl_.send_break(impl, ec);
   }
 
   /// Write the given data to the stream.
   template <typename ConstBufferSequence>
   std::size_t write_some(implementation_type& impl,
       const ConstBufferSequence& buffers, boost::system::error_code& ec)
   {
     return service_impl_.write_some(impl, buffers, ec);
   }
 
   /// Start an asynchronous write.
   template <typename ConstBufferSequence, typename WriteHandler>
   void async_write_some(implementation_type& impl,
-      const ConstBufferSequence& buffers,
-      BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
+      const ConstBufferSequence& buffers, WriteHandler handler)
   {
-    service_impl_.async_write_some(impl, buffers,
-        BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
+    service_impl_.async_write_some(impl, buffers, handler);
   }
 
   /// 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,
-      const MutableBufferSequence& buffers,
-      BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+      const MutableBufferSequence& buffers, ReadHandler handler)
   {
-    service_impl_.async_read_some(impl, buffers,
-        BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
+    service_impl_.async_read_some(impl, buffers, handler);
   }
 
 private:
-  // Destroy all user-defined handler objects owned by the service.
-  void shutdown_service()
-  {
-    service_impl_.shutdown_service();
-  }
-
   // The platform-specific implementation.
   service_impl_type service_impl_;
 };
 
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // defined(BOOST_ASIO_HAS_SERIAL_PORT)
        //   || defined(GENERATING_DOCUMENTATION)
 
 #endif // BOOST_ASIO_SERIAL_PORT_SERVICE_HPP
diff --git a/3rdParty/Boost/src/boost/asio/signal_set.hpp b/3rdParty/Boost/src/boost/asio/signal_set.hpp
deleted file mode 100644
index 3427a03..0000000
--- a/3rdParty/Boost/src/boost/asio/signal_set.hpp
+++ /dev/null
@@ -1,30 +0,0 @@
-//
-// signal_set.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_SIGNAL_SET_HPP
-#define BOOST_ASIO_SIGNAL_SET_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/basic_signal_set.hpp>
-
-namespace boost {
-namespace asio {
-
-/// Typedef for the typical usage of a signal set.
-typedef basic_signal_set<> signal_set;
-
-} // namespace asio
-} // namespace boost
-
-#endif // 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
deleted file mode 100644
index 48896f2..0000000
--- a/3rdParty/Boost/src/boost/asio/signal_set_service.hpp
+++ /dev/null
@@ -1,128 +0,0 @@
-//
-// signal_set_service.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_SIGNAL_SET_SERVICE_HPP
-#define BOOST_ASIO_SIGNAL_SET_SERVICE_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/signal_set_service.hpp>
-#include <boost/asio/error.hpp>
-#include <boost/asio/io_service.hpp>
-
-#include <boost/asio/detail/push_options.hpp>
-
-namespace boost {
-namespace asio {
-
-/// Default service implementation for a signal set.
-class signal_set_service
-#if defined(GENERATING_DOCUMENTATION)
-  : public boost::asio::io_service::service
-#else
-  : public boost::asio::detail::service_base<signal_set_service>
-#endif
-{
-public:
-#if defined(GENERATING_DOCUMENTATION)
-  /// The unique service identifier.
-  static boost::asio::io_service::id id;
-#endif
-
-public:
-  /// The type of a signal set implementation.
-#if defined(GENERATING_DOCUMENTATION)
-  typedef implementation_defined implementation_type;
-#else
-  typedef detail::signal_set_service::implementation_type implementation_type;
-#endif
-
-  /// Construct a new signal set service for the specified io_service.
-  explicit signal_set_service(boost::asio::io_service& io_service)
-    : boost::asio::detail::service_base<signal_set_service>(io_service),
-      service_impl_(io_service)
-  {
-  }
-
-  /// Construct a new signal set implementation.
-  void construct(implementation_type& impl)
-  {
-    service_impl_.construct(impl);
-  }
-
-  /// Destroy a signal set implementation.
-  void destroy(implementation_type& impl)
-  {
-    service_impl_.destroy(impl);
-  }
-
-  /// Add a signal to a signal_set.
-  boost::system::error_code add(implementation_type& impl,
-      int signal_number, boost::system::error_code& ec)
-  {
-    return service_impl_.add(impl, signal_number, ec);
-  }
-
-  /// Remove a signal to a signal_set.
-  boost::system::error_code remove(implementation_type& impl,
-      int signal_number, boost::system::error_code& ec)
-  {
-    return service_impl_.remove(impl, signal_number, ec);
-  }
-
-  /// Remove all signals from a signal_set.
-  boost::system::error_code clear(implementation_type& impl,
-      boost::system::error_code& ec)
-  {
-    return service_impl_.clear(impl, ec);
-  }
-
-  /// Cancel all operations associated with the signal set.
-  boost::system::error_code cancel(implementation_type& impl,
-      boost::system::error_code& ec)
-  {
-    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_MOVE_ARG(SignalHandler) handler)
-  {
-    service_impl_.async_wait(impl,
-        BOOST_ASIO_MOVE_CAST(SignalHandler)(handler));
-  }
-
-private:
-  // Destroy all user-defined handler objects owned by the service.
-  void shutdown_service()
-  {
-    service_impl_.shutdown_service();
-  }
-
-  // Perform any fork-related housekeeping.
-  void fork_service(boost::asio::io_service::fork_event event)
-  {
-    service_impl_.fork_service(event);
-  }
-
-  // The platform-specific implementation.
-  detail::signal_set_service service_impl_;
-};
-
-} // namespace asio
-} // namespace boost
-
-#include <boost/asio/detail/pop_options.hpp>
-
-#endif // BOOST_ASIO_SIGNAL_SET_SERVICE_HPP
diff --git a/3rdParty/Boost/src/boost/asio/socket_acceptor_service.hpp b/3rdParty/Boost/src/boost/asio/socket_acceptor_service.hpp
index 54aaf7a..f287c65 100644
--- a/3rdParty/Boost/src/boost/asio/socket_acceptor_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/socket_acceptor_service.hpp
@@ -1,277 +1,219 @@
 //
 // socket_acceptor_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_SOCKET_ACCEPTOR_SERVICE_HPP
 #define BOOST_ASIO_SOCKET_ACCEPTOR_SERVICE_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/basic_socket.hpp>
 #include <boost/asio/error.hpp>
 #include <boost/asio/io_service.hpp>
 
 #if 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>
 
 namespace boost {
 namespace asio {
 
 /// Default service implementation for a socket acceptor.
 template <typename Protocol>
 class socket_acceptor_service
 #if defined(GENERATING_DOCUMENTATION)
   : public boost::asio::io_service::service
 #else
   : public boost::asio::detail::service_base<socket_acceptor_service<Protocol> >
 #endif
 {
 public:
 #if defined(GENERATING_DOCUMENTATION)
   /// The unique service identifier.
   static boost::asio::io_service::id id;
 #endif
 
   /// The protocol type.
   typedef Protocol protocol_type;
 
   /// The endpoint type.
   typedef typename protocol_type::endpoint endpoint_type;
 
 private:
   // The type of the platform-specific implementation.
 #if 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:
   /// The native type of the socket acceptor.
 #if defined(GENERATING_DOCUMENTATION)
   typedef implementation_defined implementation_type;
 #else
   typedef typename service_impl_type::implementation_type implementation_type;
 #endif
 
-  /// (Deprecated: Use native_handle_type.) The native acceptor type.
-#if defined(GENERATING_DOCUMENTATION)
-  typedef implementation_defined native_type;
-#else
-  typedef typename service_impl_type::native_handle_type native_type;
-#endif
-
   /// The native acceptor type.
 #if defined(GENERATING_DOCUMENTATION)
-  typedef implementation_defined native_handle_type;
+  typedef implementation_defined native_type;
 #else
-  typedef typename service_impl_type::native_handle_type native_handle_type;
+  typedef typename service_impl_type::native_type native_type;
 #endif
 
   /// Construct a new socket acceptor service for the specified io_service.
   explicit socket_acceptor_service(boost::asio::io_service& io_service)
     : boost::asio::detail::service_base<
         socket_acceptor_service<Protocol> >(io_service),
       service_impl_(io_service)
   {
   }
 
-  /// Construct a new socket acceptor implementation.
-  void construct(implementation_type& impl)
-  {
-    service_impl_.construct(impl);
-  }
-
-#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
-  /// Move-construct a new socket acceptor implementation.
-  void move_construct(implementation_type& impl,
-      implementation_type& other_impl)
+  /// Destroy all user-defined handler objects owned by the service.
+  void shutdown_service()
   {
-    service_impl_.move_construct(impl, other_impl);
+    service_impl_.shutdown_service();
   }
 
-  /// Move-assign from another socket acceptor implementation.
-  void move_assign(implementation_type& impl,
-      socket_acceptor_service& other_service,
-      implementation_type& other_impl)
+  /// Construct a new socket acceptor implementation.
+  void construct(implementation_type& impl)
   {
-    service_impl_.move_assign(impl, other_service.service_impl_, other_impl);
+    service_impl_.construct(impl);
   }
-#endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
 
   /// Destroy a socket acceptor implementation.
   void destroy(implementation_type& impl)
   {
     service_impl_.destroy(impl);
   }
 
   /// Open a new socket acceptor implementation.
   boost::system::error_code open(implementation_type& impl,
       const protocol_type& protocol, boost::system::error_code& ec)
   {
     return service_impl_.open(impl, protocol, ec);
   }
 
   /// Assign an existing native acceptor to a socket acceptor.
   boost::system::error_code assign(implementation_type& impl,
-      const protocol_type& protocol, const native_handle_type& native_acceptor,
+      const protocol_type& protocol, const native_type& native_acceptor,
       boost::system::error_code& ec)
   {
     return service_impl_.assign(impl, protocol, native_acceptor, ec);
   }
 
   /// Determine whether the acceptor is open.
   bool is_open(const implementation_type& impl) const
   {
     return service_impl_.is_open(impl);
   }
 
   /// Cancel all asynchronous operations associated with the acceptor.
   boost::system::error_code cancel(implementation_type& impl,
       boost::system::error_code& ec)
   {
     return service_impl_.cancel(impl, ec);
   }
 
   /// Bind the socket acceptor to the specified local endpoint.
   boost::system::error_code bind(implementation_type& impl,
       const endpoint_type& endpoint, boost::system::error_code& ec)
   {
     return service_impl_.bind(impl, endpoint, ec);
   }
 
   /// Place the socket acceptor into the state where it will listen for new
   /// connections.
   boost::system::error_code listen(implementation_type& impl, int backlog,
       boost::system::error_code& ec)
   {
     return service_impl_.listen(impl, backlog, ec);
   }
 
   /// Close a socket acceptor implementation.
   boost::system::error_code close(implementation_type& impl,
       boost::system::error_code& ec)
   {
     return service_impl_.close(impl, ec);
   }
 
-  /// (Deprecated: Use native_handle().) Get the native acceptor implementation.
-  native_type native(implementation_type& impl)
-  {
-    return service_impl_.native_handle(impl);
-  }
-
   /// Get the native acceptor implementation.
-  native_handle_type native_handle(implementation_type& impl)
+  native_type native(implementation_type& impl)
   {
-    return service_impl_.native_handle(impl);
+    return service_impl_.native(impl);
   }
 
   /// Set a socket option.
   template <typename SettableSocketOption>
   boost::system::error_code set_option(implementation_type& impl,
       const SettableSocketOption& option, boost::system::error_code& ec)
   {
     return service_impl_.set_option(impl, option, ec);
   }
 
   /// Get a socket option.
   template <typename GettableSocketOption>
   boost::system::error_code get_option(const implementation_type& impl,
       GettableSocketOption& option, boost::system::error_code& ec) const
   {
     return service_impl_.get_option(impl, option, ec);
   }
 
   /// Perform an IO control command on the socket.
   template <typename IoControlCommand>
   boost::system::error_code io_control(implementation_type& impl,
       IoControlCommand& command, boost::system::error_code& ec)
   {
     return service_impl_.io_control(impl, command, ec);
   }
 
-  /// Gets the non-blocking mode of the acceptor.
-  bool non_blocking(const implementation_type& impl) const
-  {
-    return service_impl_.non_blocking(impl);
-  }
-
-  /// Sets the non-blocking mode of the acceptor.
-  boost::system::error_code non_blocking(implementation_type& impl,
-      bool mode, boost::system::error_code& ec)
-  {
-    return service_impl_.non_blocking(impl, mode, ec);
-  }
-
-  /// Gets the non-blocking mode of the native acceptor implementation.
-  bool native_non_blocking(const implementation_type& impl) const
-  {
-    return service_impl_.native_non_blocking(impl);
-  }
-
-  /// Sets the non-blocking mode of the native acceptor implementation.
-  boost::system::error_code native_non_blocking(implementation_type& impl,
-      bool mode, boost::system::error_code& ec)
-  {
-    return service_impl_.native_non_blocking(impl, mode, ec);
-  }
-
   /// Get the local endpoint.
   endpoint_type local_endpoint(const implementation_type& impl,
       boost::system::error_code& ec) const
   {
     return service_impl_.local_endpoint(impl, ec);
   }
 
   /// Accept a new connection.
   template <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)
   {
     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,
-      endpoint_type* peer_endpoint,
-      BOOST_ASIO_MOVE_ARG(AcceptHandler) handler)
+      endpoint_type* peer_endpoint, AcceptHandler handler)
   {
-    service_impl_.async_accept(impl, peer, peer_endpoint,
-        BOOST_ASIO_MOVE_CAST(AcceptHandler)(handler));
+    service_impl_.async_accept(impl, peer, peer_endpoint, handler);
   }
 
 private:
-  // Destroy all user-defined handler objects owned by the service.
-  void shutdown_service()
-  {
-    service_impl_.shutdown_service();
-  }
-
   // The platform-specific implementation.
   service_impl_type service_impl_;
 };
 
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // BOOST_ASIO_SOCKET_ACCEPTOR_SERVICE_HPP
diff --git a/3rdParty/Boost/src/boost/asio/socket_base.hpp b/3rdParty/Boost/src/boost/asio/socket_base.hpp
index f964d00..f5bac91 100644
--- a/3rdParty/Boost/src/boost/asio/socket_base.hpp
+++ b/3rdParty/Boost/src/boost/asio/socket_base.hpp
@@ -1,112 +1,107 @@
 //
 // socket_base.hpp
 // ~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_SOCKET_BASE_HPP
 #define BOOST_ASIO_SOCKET_BASE_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/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>
 
 namespace boost {
 namespace asio {
 
 /// The socket_base class is used as a base for the basic_stream_socket and
 /// basic_datagram_socket class templates so that we have a common place to
 /// define the shutdown_type and enum.
 class socket_base
 {
 public:
   /// Different ways a socket may be shutdown.
   enum shutdown_type
   {
 #if defined(GENERATING_DOCUMENTATION)
     /// Shutdown the receive side of the socket.
     shutdown_receive = implementation_defined,
 
     /// 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
 #endif
   };
 
   /// Bitmask type for flags that can be passed to send and receive operations.
   typedef int message_flags;
 
 #if defined(GENERATING_DOCUMENTATION)
   /// Peek at incoming data without removing it from the input queue.
   static const int message_peek = implementation_defined;
 
   /// Process out-of-band data.
   static const int message_out_of_band = implementation_defined;
 
   /// 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);
 #endif
 
   /// Socket option to permit sending of broadcast messages.
   /**
    * Implements the SOL_SOCKET/SO_BROADCAST socket option.
    *
    * @par Examples
    * Setting the option:
    * @code
    * boost::asio::ip::udp::socket socket(io_service); 
    * ...
    * boost::asio::socket_base::broadcast option(true);
    * socket.set_option(option);
    * @endcode
    *
    * @par
    * Getting the current option value:
    * @code
    * boost::asio::ip::udp::socket socket(io_service); 
    * ...
    * boost::asio::socket_base::broadcast option;
    * socket.get_option(option);
    * bool is_set = option.value();
    * @endcode
    *
    * @par Concepts:
    * 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;
 #endif
 
@@ -415,72 +410,71 @@ public:
    * Implements a custom socket option that determines whether or not an accept
    * operation is permitted to fail with boost::asio::error::connection_aborted.
    * By default the option is false.
    *
    * @par Examples
    * Setting the option:
    * @code
    * boost::asio::ip::tcp::acceptor acceptor(io_service); 
    * ...
    * boost::asio::socket_base::enable_connection_aborted option(true);
    * acceptor.set_option(option);
    * @endcode
    *
    * @par
    * Getting the current option value:
    * @code
    * boost::asio::ip::tcp::acceptor acceptor(io_service); 
    * ...
    * boost::asio::socket_base::enable_connection_aborted option;
    * acceptor.get_option(option);
    * bool is_set = option.value();
    * @endcode
    *
    * @par Concepts:
    * Socket_Option, Boolean_Socket_Option.
    */
 #if defined(GENERATING_DOCUMENTATION)
   typedef implementation_defined enable_connection_aborted;
 #else
   typedef boost::asio::detail::socket_option::boolean<
     boost::asio::detail::custom_socket_option_level,
     boost::asio::detail::enable_connection_aborted_option>
     enable_connection_aborted;
 #endif
 
-  /// (Deprecated: Use non_blocking().) IO control command to
-  /// set the blocking mode of the socket.
+  /// IO control command to set the blocking mode of the socket.
   /**
    * Implements the FIONBIO IO control command.
    *
    * @par Example
    * @code
    * boost::asio::ip::tcp::socket socket(io_service); 
    * ...
    * boost::asio::socket_base::non_blocking_io command(true);
    * socket.io_control(command);
    * @endcode
    *
    * @par Concepts:
    * IO_Control_Command, Boolean_IO_Control_Command.
    */
 #if defined(GENERATING_DOCUMENTATION)
   typedef implementation_defined non_blocking_io;
 #else
   typedef boost::asio::detail::io_control::non_blocking_io non_blocking_io;
 #endif
 
   /// IO control command to get the amount of data that can be read without
   /// blocking.
   /**
    * Implements the FIONREAD IO control command.
    *
    * @par Example
    * @code
    * boost::asio::ip::tcp::socket socket(io_service); 
    * ...
    * boost::asio::socket_base::bytes_readable command(true);
    * socket.io_control(command);
    * std::size_t bytes_readable = command.get();
    * @endcode
    *
    * @par Concepts:
diff --git a/3rdParty/Boost/src/boost/asio/strand.hpp b/3rdParty/Boost/src/boost/asio/strand.hpp
index 6a1033f..2928167 100644
--- a/3rdParty/Boost/src/boost/asio/strand.hpp
+++ b/3rdParty/Boost/src/boost/asio/strand.hpp
@@ -1,54 +1,53 @@
 //
 // strand.hpp
 // ~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_STRAND_HPP
 #define BOOST_ASIO_STRAND_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/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>
 
 namespace boost {
 namespace asio {
 
 /// Provides serialised handler execution.
 /**
  * The io_service::strand class provides the ability to post and dispatch
  * handlers with the guarantee that none of those handlers will execute
  * concurrently.
  *
  * @par Order of handler invocation
  * Given:
  *
  * @li a strand object @c s
  *
  * @li an object @c a meeting completion handler requirements
  *
  * @li an object @c a1 which is an arbitrary copy of @c a made by the
  * implementation
  *
  * @li an object @c b meeting completion handler requirements
  *
  * @li an object @c b1 which is an arbitrary copy of @c b made by the
  * implementation
  *
  * if any of the following conditions are true:
  *
  * @li @c s.post(a) happens-before @c s.post(b)
  * 
  * @li @c s.post(a) happens-before @c s.dispatch(b), where the latter is
@@ -73,138 +72,145 @@ namespace asio {
  * no ordering guarantee is made.
  *
  * @par Thread Safety
  * @e Distinct @e objects: Safe.@n
  * @e Shared @e objects: Safe.
  *
  * @par Concepts:
  * Dispatcher.
  */
 class io_service::strand
 {
 public:
   /// Constructor.
   /**
    * Constructs the strand.
    *
    * @param io_service The io_service object that the strand will use to
    * dispatch handlers that are ready to be run.
    */
   explicit strand(boost::asio::io_service& io_service)
     : service_(boost::asio::use_service<
         boost::asio::detail::strand_service>(io_service))
   {
     service_.construct(impl_);
   }
 
   /// Destructor.
   /**
    * Destroys a strand.
    *
    * Handlers posted through the strand that have not yet been invoked will
    * still be dispatched in a way that meets the guarantee of non-concurrency.
    */
   ~strand()
   {
+    service_.destroy(impl_);
+  }
+
+  /// (Deprecated: use get_io_service().) Get the io_service associated with
+  /// the strand.
+  /**
+   * This function may be used to obtain the io_service object that the strand
+   * uses to dispatch handlers for asynchronous operations.
+   *
+   * @return A reference to the io_service object that the strand will use to
+   * dispatch handlers. Ownership is not transferred to the caller.
+   */
+  boost::asio::io_service& io_service()
+  {
+    return service_.get_io_service();
   }
 
   /// Get the io_service associated with the strand.
   /**
    * This function may be used to obtain the io_service object that the strand
    * uses to dispatch handlers for asynchronous operations.
    *
    * @return A reference to the io_service object that the strand will use to
    * dispatch handlers. Ownership is not transferred to the caller.
    */
   boost::asio::io_service& get_io_service()
   {
     return service_.get_io_service();
   }
 
   /// Request the strand to invoke the given handler.
   /**
    * This function is used to ask the strand to execute the given handler.
    *
    * The strand object guarantees that handlers posted or dispatched through
    * the strand will not be executed concurrently. The handler may be executed
    * inside this function if the guarantee can be met. If this function is
    * called from within a handler that was posted or dispatched through the same
    * strand, then the new handler will be executed immediately.
    *
    * The strand's guarantee is in addition to the guarantee provided by the
    * underlying io_service. The io_service guarantees that the handler will only
    * be called in a thread in which the io_service's run member function is
    * currently being invoked.
    *
    * @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)
+  template <typename Handler>
+  void dispatch(Handler 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));
+    service_.dispatch(impl_, handler);
   }
 
   /// 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
    * without allowing the strand to call the handler from inside this function.
    *
    * The strand object guarantees that handlers posted or dispatched through
    * the strand will not be executed concurrently. The strand's guarantee is in
    * addition to the guarantee provided by the underlying io_service. The
    * io_service guarantees that the handler will only be called in a thread in
    * which the io_service's run member function is currently being invoked.
    *
    * @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)
+  template <typename Handler>
+  void post(Handler 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));
+    service_.post(impl_, handler);
   }
 
   /// 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
    * invoked, will automatically pass the wrapped handler to the strand's
    * dispatch function.
    *
    * @param handler The handler to be wrapped. The strand will make a copy of
    * the handler object as required. The function signature of the handler must
    * be: @code void handler(A1 a1, ... An an); @endcode
    *
    * @return A function object that, when invoked, passes the wrapped handler to
    * the strand's dispatch function. Given a function object with the signature:
    * @code R f(A1 a1, ... An an); @endcode
    * If this function object is passed to the wrap function like so:
    * @code strand.wrap(f); @endcode
    * then the return value is a function object with the signature
    * @code void g(A1 a1, ... An an); @endcode
    * that, when invoked, executes code equivalent to:
    * @code strand.dispatch(boost::bind(f, a1, ... an)); @endcode
    */
   template <typename Handler>
 #if defined(GENERATING_DOCUMENTATION)
   unspecified
 #else
   detail::wrapped_handler<strand, Handler>
 #endif
   wrap(Handler handler)
   {
     return detail::wrapped_handler<io_service::strand, Handler>(*this, handler);
   }
 
 private:
diff --git a/3rdParty/Boost/src/boost/asio/stream_socket_service.hpp b/3rdParty/Boost/src/boost/asio/stream_socket_service.hpp
index afc9406..40d5e18 100644
--- a/3rdParty/Boost/src/boost/asio/stream_socket_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/stream_socket_service.hpp
@@ -1,338 +1,276 @@
 //
 // stream_socket_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_STREAM_SOCKET_SERVICE_HPP
 #define BOOST_ASIO_STREAM_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>
 #include <cstddef>
 #include <boost/asio/error.hpp>
 #include <boost/asio/io_service.hpp>
 
 #if 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>
 
 namespace boost {
 namespace asio {
 
 /// Default service implementation for a stream socket.
 template <typename Protocol>
 class stream_socket_service
 #if defined(GENERATING_DOCUMENTATION)
   : public boost::asio::io_service::service
 #else
   : public boost::asio::detail::service_base<stream_socket_service<Protocol> >
 #endif
 {
 public:
 #if defined(GENERATING_DOCUMENTATION)
   /// The unique service identifier.
   static boost::asio::io_service::id id;
 #endif
 
   /// The protocol type.
   typedef Protocol protocol_type;
 
   /// The endpoint type.
   typedef typename Protocol::endpoint endpoint_type;
 
 private:
   // The type of the platform-specific implementation.
 #if 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:
   /// The type of a stream socket implementation.
 #if defined(GENERATING_DOCUMENTATION)
   typedef implementation_defined implementation_type;
 #else
   typedef typename service_impl_type::implementation_type implementation_type;
 #endif
 
-  /// (Deprecated: Use native_handle_type.) The native socket type.
-#if defined(GENERATING_DOCUMENTATION)
-  typedef implementation_defined native_type;
-#else
-  typedef typename service_impl_type::native_handle_type native_type;
-#endif
-
   /// The native socket type.
 #if defined(GENERATING_DOCUMENTATION)
-  typedef implementation_defined native_handle_type;
+  typedef implementation_defined native_type;
 #else
-  typedef typename service_impl_type::native_handle_type native_handle_type;
+  typedef typename service_impl_type::native_type native_type;
 #endif
 
   /// Construct a new stream socket service for the specified io_service.
   explicit stream_socket_service(boost::asio::io_service& io_service)
     : boost::asio::detail::service_base<
         stream_socket_service<Protocol> >(io_service),
       service_impl_(io_service)
   {
   }
 
-  /// Construct a new stream socket implementation.
-  void construct(implementation_type& impl)
-  {
-    service_impl_.construct(impl);
-  }
-
-#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
-  /// Move-construct a new stream socket implementation.
-  void move_construct(implementation_type& impl,
-      implementation_type& other_impl)
+  /// Destroy all user-defined handler objects owned by the service.
+  void shutdown_service()
   {
-    service_impl_.move_construct(impl, other_impl);
+    service_impl_.shutdown_service();
   }
 
-  /// Move-assign from another stream socket implementation.
-  void move_assign(implementation_type& impl,
-      stream_socket_service& other_service,
-      implementation_type& other_impl)
+  /// Construct a new stream socket implementation.
+  void construct(implementation_type& impl)
   {
-    service_impl_.move_assign(impl, other_service.service_impl_, other_impl);
+    service_impl_.construct(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)
       service_impl_.open(impl, protocol, ec);
     else
       ec = boost::asio::error::invalid_argument;
     return ec;
   }
 
   /// Assign an existing native socket to a stream socket.
   boost::system::error_code assign(implementation_type& impl,
-      const protocol_type& protocol, const native_handle_type& native_socket,
+      const protocol_type& protocol, const native_type& native_socket,
       boost::system::error_code& ec)
   {
     return service_impl_.assign(impl, protocol, native_socket, ec);
   }
 
   /// Determine whether the socket is open.
   bool is_open(const implementation_type& impl) const
   {
     return service_impl_.is_open(impl);
   }
 
   /// Close a stream socket implementation.
   boost::system::error_code close(implementation_type& impl,
       boost::system::error_code& ec)
   {
     return service_impl_.close(impl, ec);
   }
 
-  /// (Deprecated: Use native_handle().) Get the native socket implementation.
-  native_type native(implementation_type& impl)
-  {
-    return service_impl_.native_handle(impl);
-  }
-
   /// Get the native socket implementation.
-  native_handle_type native_handle(implementation_type& impl)
+  native_type native(implementation_type& impl)
   {
-    return service_impl_.native_handle(impl);
+    return service_impl_.native(impl);
   }
 
   /// Cancel all asynchronous operations associated with the socket.
   boost::system::error_code cancel(implementation_type& impl,
       boost::system::error_code& ec)
   {
     return service_impl_.cancel(impl, ec);
   }
 
   /// Determine whether the socket is at the out-of-band data mark.
   bool at_mark(const implementation_type& impl,
       boost::system::error_code& ec) const
   {
     return service_impl_.at_mark(impl, ec);
   }
 
   /// Determine the number of bytes available for reading.
   std::size_t available(const implementation_type& impl,
       boost::system::error_code& ec) const
   {
     return service_impl_.available(impl, ec);
   }
 
   /// Bind the stream socket to the specified local endpoint.
   boost::system::error_code bind(implementation_type& impl,
       const endpoint_type& endpoint, boost::system::error_code& ec)
   {
     return service_impl_.bind(impl, endpoint, ec);
   }
 
   /// Connect the stream socket to the specified endpoint.
   boost::system::error_code connect(implementation_type& impl,
       const endpoint_type& peer_endpoint, boost::system::error_code& ec)
   {
     return service_impl_.connect(impl, peer_endpoint, ec);
   }
 
   /// Start an asynchronous connect.
   template <typename ConnectHandler>
   void async_connect(implementation_type& impl,
-      const endpoint_type& peer_endpoint,
-      BOOST_ASIO_MOVE_ARG(ConnectHandler) handler)
+      const endpoint_type& peer_endpoint, ConnectHandler handler)
   {
-    service_impl_.async_connect(impl, peer_endpoint,
-        BOOST_ASIO_MOVE_CAST(ConnectHandler)(handler));
+    service_impl_.async_connect(impl, peer_endpoint, handler);
   }
 
   /// Set a socket option.
   template <typename SettableSocketOption>
   boost::system::error_code set_option(implementation_type& impl,
       const SettableSocketOption& option, boost::system::error_code& ec)
   {
     return service_impl_.set_option(impl, option, ec);
   }
 
   /// Get a socket option.
   template <typename GettableSocketOption>
   boost::system::error_code get_option(const implementation_type& impl,
       GettableSocketOption& option, boost::system::error_code& ec) const
   {
     return service_impl_.get_option(impl, option, ec);
   }
 
   /// Perform an IO control command on the socket.
   template <typename IoControlCommand>
   boost::system::error_code io_control(implementation_type& impl,
       IoControlCommand& command, boost::system::error_code& ec)
   {
     return service_impl_.io_control(impl, command, ec);
   }
 
-  /// Gets the non-blocking mode of the socket.
-  bool non_blocking(const implementation_type& impl) const
-  {
-    return service_impl_.non_blocking(impl);
-  }
-
-  /// Sets the non-blocking mode of the socket.
-  boost::system::error_code non_blocking(implementation_type& impl,
-      bool mode, boost::system::error_code& ec)
-  {
-    return service_impl_.non_blocking(impl, mode, ec);
-  }
-
-  /// Gets the non-blocking mode of the native socket implementation.
-  bool native_non_blocking(const implementation_type& impl) const
-  {
-    return service_impl_.native_non_blocking(impl);
-  }
-
-  /// Sets the non-blocking mode of the native socket implementation.
-  boost::system::error_code native_non_blocking(implementation_type& impl,
-      bool mode, boost::system::error_code& ec)
-  {
-    return service_impl_.native_non_blocking(impl, mode, ec);
-  }
-
   /// Get the local endpoint.
   endpoint_type local_endpoint(const implementation_type& impl,
       boost::system::error_code& ec) const
   {
     return service_impl_.local_endpoint(impl, ec);
   }
 
   /// Get the remote endpoint.
   endpoint_type remote_endpoint(const implementation_type& impl,
       boost::system::error_code& ec) const
   {
     return service_impl_.remote_endpoint(impl, ec);
   }
 
   /// Disable sends or receives on the socket.
   boost::system::error_code shutdown(implementation_type& impl,
       socket_base::shutdown_type what, boost::system::error_code& ec)
   {
     return service_impl_.shutdown(impl, what, ec);
   }
 
   /// Send the given data to the peer.
   template <typename ConstBufferSequence>
   std::size_t send(implementation_type& impl,
       const ConstBufferSequence& buffers,
       socket_base::message_flags flags, boost::system::error_code& ec)
   {
     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,
-      socket_base::message_flags flags,
-      BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
+      socket_base::message_flags flags, WriteHandler handler)
   {
-    service_impl_.async_send(impl, buffers, flags,
-        BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
+    service_impl_.async_send(impl, buffers, flags, handler);
   }
 
   /// Receive some data from the peer.
   template <typename MutableBufferSequence>
   std::size_t receive(implementation_type& impl,
       const MutableBufferSequence& buffers,
       socket_base::message_flags flags, boost::system::error_code& ec)
   {
     return service_impl_.receive(impl, buffers, flags, ec);
   }
 
   /// Start an asynchronous receive.
   template <typename MutableBufferSequence, typename ReadHandler>
   void async_receive(implementation_type& impl,
       const MutableBufferSequence& buffers,
-      socket_base::message_flags flags,
-      BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+      socket_base::message_flags flags, ReadHandler handler)
   {
-    service_impl_.async_receive(impl, buffers, flags,
-        BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
+    service_impl_.async_receive(impl, buffers, flags, handler);
   }
 
 private:
-  // Destroy all user-defined handler objects owned by the service.
-  void shutdown_service()
-  {
-    service_impl_.shutdown_service();
-  }
-
   // The platform-specific implementation.
   service_impl_type service_impl_;
 };
 
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // BOOST_ASIO_STREAM_SOCKET_SERVICE_HPP
diff --git a/3rdParty/Boost/src/boost/asio/streambuf.hpp b/3rdParty/Boost/src/boost/asio/streambuf.hpp
index 004de8d..8f724c3 100644
--- a/3rdParty/Boost/src/boost/asio/streambuf.hpp
+++ b/3rdParty/Boost/src/boost/asio/streambuf.hpp
@@ -1,35 +1,35 @@
 //
 // streambuf.hpp
 // ~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_STREAMBUF_HPP
 #define BOOST_ASIO_STREAMBUF_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_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 // 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..0da7e6b 100644
--- a/3rdParty/Boost/src/boost/asio/time_traits.hpp
+++ b/3rdParty/Boost/src/boost/asio/time_traits.hpp
@@ -1,40 +1,40 @@
 //
 // time_traits.hpp
 // ~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_TIME_TRAITS_HPP
 #define BOOST_ASIO_TIME_TRAITS_HPP
 
 #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.
 
 #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>
 
 namespace boost {
 namespace asio {
 
 /// Time traits suitable for use with the deadline timer.
 template <typename Time>
 struct time_traits;
 
 /// Time traits specialised for posix_time.
 template <>
 struct time_traits<boost::posix_time::ptime>
 {
   /// The time type.
   typedef boost::posix_time::ptime time_type;
 
   /// The duration type.
diff --git a/3rdParty/Boost/src/boost/asio/version.hpp b/3rdParty/Boost/src/boost/asio/version.hpp
index 4fc894b..9ef5ab5 100644
--- a/3rdParty/Boost/src/boost/asio/version.hpp
+++ b/3rdParty/Boost/src/boost/asio/version.hpp
@@ -1,23 +1,23 @@
 //
 // version.hpp
 // ~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_VERSION_HPP
 #define BOOST_ASIO_VERSION_HPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # 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 100409 // 1.4.9
 
 #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
deleted file mode 100644
index c4eef20..0000000
--- a/3rdParty/Boost/src/boost/asio/wait_traits.hpp
+++ /dev/null
@@ -1,43 +0,0 @@
-//
-// wait_traits.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_WAIT_TRAITS_HPP
-#define BOOST_ASIO_WAIT_TRAITS_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include <boost/asio/detail/push_options.hpp>
-
-namespace boost {
-namespace asio {
-
-/// Wait traits suitable for use with the basic_waitable_timer class template.
-template <typename Clock>
-struct wait_traits
-{
-  /// Convert a clock duration into a duration used for waiting.
-  /** 
-   * @returns @c d.
-   */
-  static typename Clock::duration to_wait_duration(
-      const typename Clock::duration& d)
-  {
-    return d;
-  }
-};
-
-} // namespace asio
-} // namespace boost
-
-#include <boost/asio/detail/pop_options.hpp>
-
-#endif // 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
deleted file mode 100644
index 69a9580..0000000
--- a/3rdParty/Boost/src/boost/asio/waitable_timer_service.hpp
+++ /dev/null
@@ -1,161 +0,0 @@
-//
-// waitable_timer_service.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_WAITABLE_TIMER_SERVICE_HPP
-#define BOOST_ASIO_WAITABLE_TIMER_SERVICE_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/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>
-
-namespace boost {
-namespace asio {
-
-/// Default service implementation for a timer.
-template <typename Clock,
-    typename WaitTraits = boost::asio::wait_traits<Clock> >
-class waitable_timer_service
-#if defined(GENERATING_DOCUMENTATION)
-  : public boost::asio::io_service::service
-#else
-  : public boost::asio::detail::service_base<
-      waitable_timer_service<Clock, WaitTraits> >
-#endif
-{
-public:
-#if defined(GENERATING_DOCUMENTATION)
-  /// The unique service identifier.
-  static boost::asio::io_service::id id;
-#endif
-
-  /// The clock type.
-  typedef Clock clock_type;
-
-  /// The duration type of the clock.
-  typedef typename clock_type::duration duration;
-
-  /// The time point type of the clock.
-  typedef typename clock_type::time_point time_point;
-
-  /// The wait traits type.
-  typedef WaitTraits traits_type;
-
-private:
-  // The type of the platform-specific implementation.
-  typedef detail::deadline_timer_service<
-    detail::chrono_time_traits<Clock, WaitTraits> > service_impl_type;
-
-public:
-  /// The implementation type of the waitable timer.
-#if defined(GENERATING_DOCUMENTATION)
-  typedef implementation_defined implementation_type;
-#else
-  typedef typename service_impl_type::implementation_type implementation_type;
-#endif
-
-  /// Construct a new timer service for the specified io_service.
-  explicit waitable_timer_service(boost::asio::io_service& io_service)
-    : boost::asio::detail::service_base<
-        waitable_timer_service<Clock, WaitTraits> >(io_service),
-      service_impl_(io_service)
-  {
-  }
-
-  /// Construct a new timer implementation.
-  void construct(implementation_type& impl)
-  {
-    service_impl_.construct(impl);
-  }
-
-  /// Destroy a timer implementation.
-  void destroy(implementation_type& impl)
-  {
-    service_impl_.destroy(impl);
-  }
-
-  /// Cancel any asynchronous wait operations associated with the timer.
-  std::size_t cancel(implementation_type& impl, boost::system::error_code& ec)
-  {
-    return service_impl_.cancel(impl, ec);
-  }
-
-  /// Cancels one asynchronous wait operation associated with the timer.
-  std::size_t cancel_one(implementation_type& impl,
-      boost::system::error_code& ec)
-  {
-    return service_impl_.cancel_one(impl, ec);
-  }
-
-  /// Get the expiry time for the timer as an absolute time.
-  time_point expires_at(const implementation_type& impl) const
-  {
-    return service_impl_.expires_at(impl);
-  }
-
-  /// Set the expiry time for the timer as an absolute time.
-  std::size_t expires_at(implementation_type& impl,
-      const time_point& expiry_time, boost::system::error_code& ec)
-  {
-    return service_impl_.expires_at(impl, expiry_time, ec);
-  }
-
-  /// Get the expiry time for the timer relative to now.
-  duration expires_from_now(const implementation_type& impl) const
-  {
-    return service_impl_.expires_from_now(impl);
-  }
-
-  /// Set the expiry time for the timer relative to now.
-  std::size_t expires_from_now(implementation_type& impl,
-      const duration& expiry_time, boost::system::error_code& ec)
-  {
-    return service_impl_.expires_from_now(impl, expiry_time, ec);
-  }
-
-  // Perform a blocking wait on the timer.
-  void wait(implementation_type& impl, boost::system::error_code& ec)
-  {
-    service_impl_.wait(impl, ec);
-  }
-
-  // Start an asynchronous wait on the timer.
-  template <typename WaitHandler>
-  void async_wait(implementation_type& impl,
-      BOOST_ASIO_MOVE_ARG(WaitHandler) handler)
-  {
-    service_impl_.async_wait(impl, BOOST_ASIO_MOVE_CAST(WaitHandler)(handler));
-  }
-
-private:
-  // Destroy all user-defined handler objects owned by the service.
-  void shutdown_service()
-  {
-    service_impl_.shutdown_service();
-  }
-
-  // The platform-specific implementation.
-  service_impl_type service_impl_;
-};
-
-} // namespace asio
-} // namespace boost
-
-#include <boost/asio/detail/pop_options.hpp>
-
-#endif // BOOST_ASIO_WAITABLE_TIMER_SERVICE_HPP
diff --git a/3rdParty/Boost/src/boost/asio/windows/basic_handle.hpp b/3rdParty/Boost/src/boost/asio/windows/basic_handle.hpp
index 5169cae..aedd79a 100644
--- a/3rdParty/Boost/src/boost/asio/windows/basic_handle.hpp
+++ b/3rdParty/Boost/src/boost/asio/windows/basic_handle.hpp
@@ -1,283 +1,233 @@
 //
 // windows/basic_handle.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_WINDOWS_BASIC_HANDLE_HPP
 #define BOOST_ASIO_WINDOWS_BASIC_HANDLE_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_WINDOWS_RANDOM_ACCESS_HANDLE) \
   || defined(BOOST_ASIO_HAS_WINDOWS_STREAM_HANDLE) \
-  || defined(BOOST_ASIO_HAS_WINDOWS_OBJECT_HANDLE) \
   || defined(GENERATING_DOCUMENTATION)
 
 #include <boost/asio/basic_io_object.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 windows {
 
 /// Provides Windows handle functionality.
 /**
  * The windows::basic_handle class template provides the ability to wrap a
  * Windows handle.
  *
  * @par Thread Safety
  * @e Distinct @e objects: Safe.@n
  * @e Shared @e objects: Unsafe.
  */
 template <typename HandleService>
 class basic_handle
   : public basic_io_object<HandleService>
 {
 public:
-  /// (Deprecated: Use native_handle_type.) The native representation of a
-  /// handle.
-  typedef typename HandleService::native_handle_type native_type;
-
   /// The native representation of a handle.
-  typedef typename HandleService::native_handle_type native_handle_type;
+  typedef typename HandleService::native_type native_type;
 
   /// A basic_handle is always the lowest layer.
   typedef basic_handle<HandleService> lowest_layer_type;
 
   /// Construct a basic_handle without opening it.
   /**
    * This constructor creates a handle without opening it.
    *
    * @param io_service The io_service object that the handle will use to
    * dispatch handlers for any asynchronous operations performed on the handle.
    */
   explicit basic_handle(boost::asio::io_service& io_service)
     : basic_io_object<HandleService>(io_service)
   {
   }
 
   /// Construct a basic_handle on an existing native handle.
   /**
    * This constructor creates a handle object to hold an existing native handle.
    *
    * @param io_service The io_service object that the handle will use to
    * dispatch handlers for any asynchronous operations performed on the handle.
    *
-   * @param handle A native handle.
+   * @param native_handle A native handle.
    *
    * @throws boost::system::system_error Thrown on failure.
    */
   basic_handle(boost::asio::io_service& io_service,
-      const native_handle_type& handle)
+      const native_type& native_handle)
     : basic_io_object<HandleService>(io_service)
   {
     boost::system::error_code ec;
-    this->get_service().assign(this->get_implementation(), handle, ec);
-    boost::asio::detail::throw_error(ec, "assign");
-  }
-
-#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
-  /// Move-construct a basic_handle from another.
-  /**
-   * This constructor moves a handle from one object to another.
-   *
-   * @param other The other basic_handle 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_handle(io_service&) constructor.
-   */
-  basic_handle(basic_handle&& other)
-    : basic_io_object<HandleService>(
-        BOOST_ASIO_MOVE_CAST(basic_handle)(other))
-  {
-  }
-
-  /// Move-assign a basic_handle from another.
-  /**
-   * This assignment operator moves a handle from one object to another.
-   *
-   * @param other The other basic_handle 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_handle(io_service&) constructor.
-   */
-  basic_handle& operator=(basic_handle&& other)
-  {
-    basic_io_object<HandleService>::operator=(
-        BOOST_ASIO_MOVE_CAST(basic_handle)(other));
-    return *this;
+    this->service.assign(this->implementation, native_handle, ec);
+    boost::asio::detail::throw_error(ec);
   }
-#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_handle cannot contain any further layers, it simply
    * returns a reference to itself.
    *
    * @return A reference to the lowest layer in the stack of layers. Ownership
    * is not transferred to the caller.
    */
   lowest_layer_type& lowest_layer()
   {
     return *this;
   }
 
   /// Get a const reference to the lowest layer.
   /**
    * This function returns a const reference to the lowest layer in a stack of
    * layers. Since a basic_handle cannot contain any further layers, it simply
    * returns a reference to itself.
    *
    * @return A const reference to the lowest layer in the stack of layers.
    * Ownership is not transferred to the caller.
    */
   const lowest_layer_type& lowest_layer() const
   {
     return *this;
   }
 
   /// Assign an existing native handle to the handle.
   /*
    * This function opens the handle to hold an existing native handle.
    *
-   * @param handle A native handle.
+   * @param native_handle A native handle.
    *
    * @throws boost::system::system_error Thrown on failure.
    */
-  void assign(const native_handle_type& handle)
+  void assign(const native_type& native_handle)
   {
     boost::system::error_code ec;
-    this->get_service().assign(this->get_implementation(), handle, ec);
-    boost::asio::detail::throw_error(ec, "assign");
+    this->service.assign(this->implementation, native_handle, ec);
+    boost::asio::detail::throw_error(ec);
   }
 
   /// Assign an existing native handle to the handle.
   /*
    * This function opens the handle to hold an existing native handle.
    *
-   * @param handle A native handle.
+   * @param native_handle A native handle.
    *
    * @param ec Set to indicate what error occurred, if any.
    */
-  boost::system::error_code assign(const native_handle_type& handle,
+  boost::system::error_code assign(const native_type& native_handle,
       boost::system::error_code& ec)
   {
-    return this->get_service().assign(this->get_implementation(), handle, ec);
+    return this->service.assign(this->implementation, native_handle, ec);
   }
 
   /// Determine whether the handle is open.
   bool is_open() const
   {
-    return this->get_service().is_open(this->get_implementation());
+    return this->service.is_open(this->implementation);
   }
 
   /// Close the handle.
   /**
    * This function is used to close the handle. Any asynchronous read or write
    * operations will be cancelled immediately, and will complete with the
    * boost::asio::error::operation_aborted error.
    *
    * @throws boost::system::system_error Thrown on failure.
    */
   void close()
   {
     boost::system::error_code ec;
-    this->get_service().close(this->get_implementation(), ec);
-    boost::asio::detail::throw_error(ec, "close");
+    this->service.close(this->implementation, ec);
+    boost::asio::detail::throw_error(ec);
   }
 
   /// Close the handle.
   /**
    * This function is used to close the handle. Any asynchronous read or write
    * operations will be cancelled immediately, and will complete with the
    * boost::asio::error::operation_aborted error.
    *
    * @param ec Set to indicate what error occurred, if any.
    */
   boost::system::error_code close(boost::system::error_code& ec)
   {
-    return this->get_service().close(this->get_implementation(), ec);
-  }
-
-  /// (Deprecated: Use native_handle().) Get the native handle representation.
-  /**
-   * This function may be used to obtain the underlying representation of the
-   * handle. This is intended to allow access to native handle functionality
-   * that is not otherwise provided.
-   */
-  native_type native()
-  {
-    return this->get_service().native_handle(this->get_implementation());
+    return this->service.close(this->implementation, ec);
   }
 
   /// Get the native handle representation.
   /**
    * This function may be used to obtain the underlying representation of the
    * handle. This is intended to allow access to native handle functionality
    * that is not otherwise provided.
    */
-  native_handle_type native_handle()
+  native_type native()
   {
-    return this->get_service().native_handle(this->get_implementation());
+    return this->service.native(this->implementation);
   }
 
   /// Cancel all asynchronous operations associated with the handle.
   /**
    * This function causes all outstanding asynchronous read or write operations
    * to finish immediately, and the handlers for cancelled operations will be
    * passed the boost::asio::error::operation_aborted error.
    *
    * @throws boost::system::system_error Thrown on failure.
    */
   void cancel()
   {
     boost::system::error_code ec;
-    this->get_service().cancel(this->get_implementation(), ec);
-    boost::asio::detail::throw_error(ec, "cancel");
+    this->service.cancel(this->implementation, ec);
+    boost::asio::detail::throw_error(ec);
   }
 
   /// Cancel all asynchronous operations associated with the handle.
   /**
    * This function causes all outstanding asynchronous read or write operations
    * to finish immediately, and the handlers for cancelled operations will be
    * passed the boost::asio::error::operation_aborted error.
    *
    * @param ec Set to indicate what error occurred, if any.
    */
   boost::system::error_code cancel(boost::system::error_code& ec)
   {
-    return this->get_service().cancel(this->get_implementation(), ec);
+    return this->service.cancel(this->implementation, ec);
   }
 
 protected:
   /// Protected destructor to prevent deletion through this type.
   ~basic_handle()
   {
   }
 };
 
 } // namespace windows
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // defined(BOOST_ASIO_HAS_WINDOWS_RANDOM_ACCESS_HANDLE)
        //   || defined(BOOST_ASIO_HAS_WINDOWS_STREAM_HANDLE)
-       //   || defined(BOOST_ASIO_HAS_WINDOWS_OBJECT_HANDLE)
        //   || defined(GENERATING_DOCUMENTATION)
 
 #endif // 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
deleted file mode 100644
index a94bb57..0000000
--- a/3rdParty/Boost/src/boost/asio/windows/basic_object_handle.hpp
+++ /dev/null
@@ -1,177 +0,0 @@
-//
-// windows/basic_object_handle.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2012 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)
-//
-
-#ifndef BOOST_ASIO_WINDOWS_BASIC_OBJECT_HANDLE_HPP
-#define BOOST_ASIO_WINDOWS_BASIC_OBJECT_HANDLE_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_WINDOWS_OBJECT_HANDLE) \
-  || defined(GENERATING_DOCUMENTATION)
-
-#include <boost/asio/detail/throw_error.hpp>
-#include <boost/asio/error.hpp>
-#include <boost/asio/windows/basic_handle.hpp>
-#include <boost/asio/windows/object_handle_service.hpp>
-
-#include <boost/asio/detail/push_options.hpp>
-
-namespace boost {
-namespace asio {
-namespace windows {
-
-/// Provides object-oriented handle functionality.
-/**
- * The windows::basic_object_handle class template provides asynchronous and
- * blocking object-oriented handle functionality.
- *
- * @par Thread Safety
- * @e Distinct @e objects: Safe.@n
- * @e Shared @e objects: Unsafe.
- */
-template <typename ObjectHandleService = object_handle_service>
-class basic_object_handle
-  : public basic_handle<ObjectHandleService>
-{
-public:
-  /// The native representation of a handle.
-  typedef typename ObjectHandleService::native_handle_type native_handle_type;
-
-  /// Construct a basic_object_handle without opening it.
-  /**
-   * This constructor creates an object handle without opening it.
-   *
-   * @param io_service The io_service object that the object handle will use to
-   * dispatch handlers for any asynchronous operations performed on the handle.
-   */
-  explicit basic_object_handle(boost::asio::io_service& io_service)
-    : basic_handle<ObjectHandleService>(io_service)
-  {
-  }
-
-  /// Construct a basic_object_handle on an existing native handle.
-  /**
-   * This constructor creates an object handle object to hold an existing native
-   * handle.
-   *
-   * @param io_service The io_service object that the object handle will use to
-   * dispatch handlers for any asynchronous operations performed on the handle.
-   *
-   * @param native_handle The new underlying handle implementation.
-   *
-   * @throws boost::system::system_error Thrown on failure.
-   */
-  basic_object_handle(boost::asio::io_service& io_service,
-      const native_handle_type& native_handle)
-    : basic_handle<ObjectHandleService>(io_service, native_handle)
-  {
-  }
-
-#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
-  /// Move-construct a basic_object_handle from another.
-  /**
-   * This constructor moves an object handle from one object to another.
-   *
-   * @param other The other basic_object_handle 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_object_handle(io_service&) constructor.
-   */
-  basic_object_handle(basic_object_handle&& other)
-    : basic_handle<ObjectHandleService>(
-        BOOST_ASIO_MOVE_CAST(basic_object_handle)(other))
-  {
-  }
-
-  /// Move-assign a basic_object_handle from another.
-  /**
-   * This assignment operator moves an object handle from one object to another.
-   *
-   * @param other The other basic_object_handle 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_object_handle(io_service&) constructor.
-   */
-  basic_object_handle& operator=(basic_object_handle&& other)
-  {
-    basic_handle<ObjectHandleService>::operator=(
-        BOOST_ASIO_MOVE_CAST(basic_object_handle)(other));
-    return *this;
-  }
-#endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
-
-  /// Perform a blocking wait on the object handle.
-  /**
-   * This function is used to wait for the object handle to be set to the
-   * signalled state. This function blocks and does not return until the object
-   * handle has been set to the signalled state.
-   *
-   * @throws boost::system::system_error Thrown on failure.
-   */
-  void wait()
-  {
-    boost::system::error_code ec;
-    this->get_service().wait(this->get_implementation(), ec);
-    boost::asio::detail::throw_error(ec, "wait");
-  }
-
-  /// Perform a blocking wait on the object handle.
-  /**
-   * This function is used to wait for the object handle to be set to the
-   * signalled state. This function blocks and does not return until the object
-   * handle has been set to the signalled state.
-   *
-   * @param ec Set to indicate what error occurred, if any.
-   */
-  void wait(boost::system::error_code& ec)
-  {
-    this->get_service().wait(this->get_implementation(), ec);
-  }
-
-  /// Start an asynchronous wait on the object handle.
-  /**
-   * This function is be used to initiate an asynchronous wait against the
-   * object handle. It always returns immediately.
-   *
-   * @param handler The handler to be called when the object handle is set to
-   * the signalled state. Copies will be made of the handler as required. The
-   * function signature of the handler must be:
-   * @code void handler(
-   *   const boost::system::error_code& error // Result of operation.
-   * ); @endcode
-   * 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)
-  {
-    this->get_service().async_wait(this->get_implementation(), handler);
-  }
-};
-
-} // namespace windows
-} // namespace asio
-} // namespace boost
-
-#include <boost/asio/detail/pop_options.hpp>
-
-#endif // defined(BOOST_ASIO_HAS_WINDOWS_OBJECT_HANDLE)
-       //   || defined(GENERATING_DOCUMENTATION)
-
-#endif // BOOST_ASIO_WINDOWS_BASIC_OBJECT_HANDLE_HPP
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..207e414 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,374 +1,320 @@
 //
 // windows/basic_random_access_handle.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_WINDOWS_BASIC_RANDOM_ACCESS_HANDLE_HPP
 #define BOOST_ASIO_WINDOWS_BASIC_RANDOM_ACCESS_HANDLE_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_WINDOWS_RANDOM_ACCESS_HANDLE) \
   || defined(GENERATING_DOCUMENTATION)
 
 #include <cstddef>
-#include <boost/asio/detail/handler_type_requirements.hpp>
 #include <boost/asio/detail/throw_error.hpp>
 #include <boost/asio/error.hpp>
 #include <boost/asio/windows/basic_handle.hpp>
 #include <boost/asio/windows/random_access_handle_service.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace windows {
 
 /// Provides random-access handle functionality.
 /**
  * The windows::basic_random_access_handle class template provides asynchronous
  * and blocking random-access handle functionality.
  *
  * @par Thread Safety
  * @e Distinct @e objects: Safe.@n
  * @e Shared @e objects: Unsafe.
  */
 template <typename RandomAccessHandleService = random_access_handle_service>
 class basic_random_access_handle
   : public basic_handle<RandomAccessHandleService>
 {
 public:
-  /// (Deprecated: Use native_handle_type.) The native representation of a
-  /// handle.
-  typedef typename RandomAccessHandleService::native_handle_type native_type;
-
   /// The native representation of a handle.
-  typedef typename RandomAccessHandleService::native_handle_type
-    native_handle_type;
+  typedef typename RandomAccessHandleService::native_type native_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.
    *
    * @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)
     : basic_handle<RandomAccessHandleService>(io_service)
   {
   }
 
   /// Construct a basic_random_access_handle on an existing native handle.
   /**
    * This constructor creates a random-access handle object to hold an existing
    * native handle.
    *
    * @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.
    *
-   * @param handle The new underlying handle implementation.
+   * @param native_handle The new underlying handle implementation.
    *
    * @throws boost::system::system_error Thrown on failure.
    */
   basic_random_access_handle(boost::asio::io_service& io_service,
-      const native_handle_type& handle)
-    : basic_handle<RandomAccessHandleService>(io_service, handle)
+      const native_type& native_handle)
+    : basic_handle<RandomAccessHandleService>(io_service, native_handle)
   {
   }
 
-#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
-  /// Move-construct a basic_random_access_handle from another.
-  /**
-   * This constructor moves a random-access handle from one object to another.
-   *
-   * @param other The other basic_random_access_handle 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_random_access_handle(io_service&)
-   * constructor.
-   */
-  basic_random_access_handle(basic_random_access_handle&& other)
-    : basic_handle<RandomAccessHandleService>(
-        BOOST_ASIO_MOVE_CAST(basic_random_access_handle)(other))
-  {
-  }
-
-  /// Move-assign a basic_random_access_handle from another.
-  /**
-   * This assignment operator moves a random-access handle from one object to
-   * another.
-   *
-   * @param other The other basic_random_access_handle 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_random_access_handle(io_service&)
-   * constructor.
-   */
-  basic_random_access_handle& operator=(basic_random_access_handle&& other)
-  {
-    basic_handle<RandomAccessHandleService>::operator=(
-        BOOST_ASIO_MOVE_CAST(basic_random_access_handle)(other));
-    return *this;
-  }
-#endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
-
   /// Write some data to the handle at the specified offset.
   /**
    * This function is used to write data to the random-access handle. The
    * function call will block until one or more bytes of the data has been
    * written successfully, or until an error occurs.
    *
    * @param offset The offset at which the data will be written.
    *
    * @param buffers One or more data buffers to be written to the handle.
    *
    * @returns The number of bytes written.
    *
    * @throws boost::system::system_error Thrown on failure. An error code of
    * boost::asio::error::eof indicates that the connection was closed by the
    * peer.
    *
    * @note The write_some_at operation may not write all of the data. Consider
    * using the @ref write_at function if you need to ensure that all data is
    * written before the blocking operation completes.
    *
    * @par Example
    * To write a single data buffer use the @ref buffer function as follows:
    * @code
    * handle.write_some_at(42, boost::asio::buffer(data, size));
    * @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,
       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");
+    std::size_t s = this->service.write_some_at(
+        this->implementation, offset, buffers, ec);
+    boost::asio::detail::throw_error(ec);
     return s;
   }
 
   /// Write some data to the handle at the specified offset.
   /**
    * This function is used to write data to the random-access handle. The
    * function call will block until one or more bytes of the data has been
    * written successfully, or until an error occurs.
    *
    * @param offset The offset at which the data will be written.
    *
    * @param buffers One or more data buffers to be written to the handle.
    *
    * @param ec Set to indicate what error occurred, if any.
    *
    * @returns The number of bytes written. Returns 0 if an error occurred.
    *
    * @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,
       const ConstBufferSequence& buffers, boost::system::error_code& ec)
   {
-    return this->get_service().write_some_at(
-        this->get_implementation(), offset, buffers, ec);
+    return this->service.write_some_at(
+        this->implementation, offset, buffers, ec);
   }
 
   /// Start an asynchronous write at the specified offset.
   /**
    * This function is used to asynchronously write data to the random-access
    * handle. The function call always returns immediately.
    *
    * @param offset The offset at which the data will be written.
    *
    * @param buffers One or more data buffers to be written to the handle.
    * 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.
    *
    * @param handler The handler to be called when the write operation completes.
    * Copies will be made of the handler as required. The function signature of
    * the handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
    *   std::size_t bytes_transferred           // Number of bytes written.
    * ); @endcode
    * 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().
    *
    * @note The write operation may not transmit all of the data to the peer.
    * Consider using the @ref async_write_at function if you need to ensure that
    * all data is written before the asynchronous operation completes.
    *
    * @par Example
    * To write a single data buffer use the @ref buffer function as follows:
    * @code
    * handle.async_write_some_at(42, boost::asio::buffer(data, size), handler);
    * @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,
-      const ConstBufferSequence& buffers,
-      BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
+      const ConstBufferSequence& buffers, 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(),
-        offset, buffers, BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
+    this->service.async_write_some_at(
+        this->implementation, offset, buffers, handler);
   }
 
   /// Read some data from the handle at the specified offset.
   /**
    * This function is used to read data from the random-access handle. The
    * function call will block until one or more bytes of data has been read
    * successfully, or until an error occurs.
    *
    * @param offset The offset at which the data will be read.
    *
    * @param buffers One or more buffers into which the data will be read.
    *
    * @returns The number of bytes read.
    *
    * @throws boost::system::system_error Thrown on failure. An error code of
    * boost::asio::error::eof indicates that the connection was closed by the
    * peer.
    *
    * @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.
    *
    * @par Example
    * To read into a single data buffer use the @ref buffer function as follows:
    * @code
    * handle.read_some_at(42, boost::asio::buffer(data, size));
    * @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,
       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");
+    std::size_t s = this->service.read_some_at(
+        this->implementation, offset, buffers, ec);
+    boost::asio::detail::throw_error(ec);
     return s;
   }
 
   /// Read some data from the handle at the specified offset.
   /**
    * This function is used to read data from the random-access handle. The
    * function call will block until one or more bytes of data has been read
    * successfully, or until an error occurs.
    *
    * @param offset The offset at which the data will be read.
    *
    * @param buffers One or more buffers into which the data will be read.
    *
    * @param ec Set to indicate what error occurred, if any.
    *
    * @returns The number of bytes read. Returns 0 if an error occurred.
    *
    * @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,
       const MutableBufferSequence& buffers, boost::system::error_code& ec)
   {
-    return this->get_service().read_some_at(
-        this->get_implementation(), offset, buffers, ec);
+    return this->service.read_some_at(
+        this->implementation, offset, buffers, ec);
   }
 
   /// Start an asynchronous read at the specified offset.
   /**
    * This function is used to asynchronously read data from the random-access
    * handle. The function call always returns immediately.
    *
    * @param offset The offset at which the data will be read.
    *
    * @param buffers One or more buffers into which the data will be read.
    * 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.
    *
    * @param handler The handler to be called when the read operation completes.
    * Copies will be made of the handler as required. The function signature of
    * the handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
    *   std::size_t bytes_transferred           // Number of bytes read.
    * ); @endcode
    * 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().
    *
    * @note The read operation may not read all of the requested number of bytes.
    * Consider using the @ref async_read_at function if you need to ensure that
    * the requested amount of data is read before the asynchronous operation
    * completes.
    *
    * @par Example
    * To read into a single data buffer use the @ref buffer function as follows:
    * @code
    * handle.async_read_some_at(42, boost::asio::buffer(data, size), handler);
    * @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,
-      const MutableBufferSequence& buffers,
-      BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+      const MutableBufferSequence& buffers, 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(),
-        offset, buffers, BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
+    this->service.async_read_some_at(
+        this->implementation, offset, buffers, handler);
   }
 };
 
 } // namespace windows
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // defined(BOOST_ASIO_HAS_WINDOWS_RANDOM_ACCESS_HANDLE)
        //   || defined(GENERATING_DOCUMENTATION)
 
 #endif // BOOST_ASIO_WINDOWS_BASIC_RANDOM_ACCESS_HANDLE_HPP
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..105b041 100644
--- a/3rdParty/Boost/src/boost/asio/windows/basic_stream_handle.hpp
+++ b/3rdParty/Boost/src/boost/asio/windows/basic_stream_handle.hpp
@@ -1,357 +1,302 @@
 //
 // windows/basic_stream_handle.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_WINDOWS_BASIC_STREAM_HANDLE_HPP
 #define BOOST_ASIO_WINDOWS_BASIC_STREAM_HANDLE_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_WINDOWS_STREAM_HANDLE) \
   || defined(GENERATING_DOCUMENTATION)
 
 #include <cstddef>
-#include <boost/asio/detail/handler_type_requirements.hpp>
-#include <boost/asio/detail/throw_error.hpp>
 #include <boost/asio/error.hpp>
 #include <boost/asio/windows/basic_handle.hpp>
 #include <boost/asio/windows/stream_handle_service.hpp>
+#include <boost/asio/detail/throw_error.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace windows {
 
 /// Provides stream-oriented handle functionality.
 /**
  * The windows::basic_stream_handle class template provides asynchronous and
  * blocking stream-oriented handle functionality.
  *
  * @par Thread Safety
  * @e Distinct @e objects: Safe.@n
  * @e Shared @e objects: Unsafe.
  *
  * @par Concepts:
  * AsyncReadStream, AsyncWriteStream, Stream, SyncReadStream, SyncWriteStream.
  */
 template <typename StreamHandleService = stream_handle_service>
 class basic_stream_handle
   : public basic_handle<StreamHandleService>
 {
 public:
-  /// (Deprecated: Use native_handle_type.) The native representation of a
-  /// handle.
-  typedef typename StreamHandleService::native_handle_type native_type;
-
   /// The native representation of a handle.
-  typedef typename StreamHandleService::native_handle_type native_handle_type;
+  typedef typename StreamHandleService::native_type native_type;
 
   /// Construct a basic_stream_handle without opening it.
   /**
    * This constructor creates a stream handle without opening it. The handle
    * needs to be opened and then connected or accepted before data can be sent
    * or received on it.
    *
    * @param io_service The io_service object that the stream handle will use to
    * dispatch handlers for any asynchronous operations performed on the handle.
    */
   explicit basic_stream_handle(boost::asio::io_service& io_service)
     : basic_handle<StreamHandleService>(io_service)
   {
   }
 
   /// Construct a basic_stream_handle on an existing native handle.
   /**
    * This constructor creates a stream handle object to hold an existing native
    * handle.
    *
    * @param io_service The io_service object that the stream handle will use to
    * dispatch handlers for any asynchronous operations performed on the handle.
    *
-   * @param handle The new underlying handle implementation.
+   * @param native_handle The new underlying handle implementation.
    *
    * @throws boost::system::system_error Thrown on failure.
    */
   basic_stream_handle(boost::asio::io_service& io_service,
-      const native_handle_type& handle)
-    : basic_handle<StreamHandleService>(io_service, handle)
-  {
-  }
-
-#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
-  /// Move-construct a basic_stream_handle from another.
-  /**
-   * This constructor moves a stream handle from one object to another.
-   *
-   * @param other The other basic_stream_handle 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_handle(io_service&) constructor.
-   */
-  basic_stream_handle(basic_stream_handle&& other)
-    : basic_handle<StreamHandleService>(
-        BOOST_ASIO_MOVE_CAST(basic_stream_handle)(other))
+      const native_type& native_handle)
+    : basic_handle<StreamHandleService>(io_service, native_handle)
   {
   }
 
-  /// Move-assign a basic_stream_handle from another.
-  /**
-   * This assignment operator moves a stream handle from one object to
-   * another.
-   *
-   * @param other The other basic_stream_handle 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_handle(io_service&) constructor.
-   */
-  basic_stream_handle& operator=(basic_stream_handle&& other)
-  {
-    basic_handle<StreamHandleService>::operator=(
-        BOOST_ASIO_MOVE_CAST(basic_stream_handle)(other));
-    return *this;
-  }
-#endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
-
   /// Write some data to the handle.
   /**
    * This function is used to write data to the stream handle. The function call
    * will block until one or more bytes of the data has been written
    * successfully, or until an error occurs.
    *
    * @param buffers One or more data buffers to be written to the handle.
    *
    * @returns The number of bytes written.
    *
    * @throws boost::system::system_error Thrown on failure. An error code of
    * boost::asio::error::eof indicates that the connection was closed by the
    * peer.
    *
    * @note The write_some operation may not transmit all of the data to the
    * peer. Consider using the @ref write function if you need to ensure that
    * all data is written before the blocking operation completes.
    *
    * @par Example
    * To write a single data buffer use the @ref buffer function as follows:
    * @code
    * handle.write_some(boost::asio::buffer(data, size));
    * @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(const ConstBufferSequence& buffers)
   {
     boost::system::error_code ec;
-    std::size_t s = this->get_service().write_some(
-        this->get_implementation(), buffers, ec);
-    boost::asio::detail::throw_error(ec, "write_some");
+    std::size_t s = this->service.write_some(this->implementation, buffers, ec);
+    boost::asio::detail::throw_error(ec);
     return s;
   }
 
   /// Write some data to the handle.
   /**
    * This function is used to write data to the stream handle. The function call
    * will block until one or more bytes of the data has been written
    * successfully, or until an error occurs.
    *
    * @param buffers One or more data buffers to be written to the handle.
    *
    * @param ec Set to indicate what error occurred, if any.
    *
    * @returns The number of bytes written. Returns 0 if an error occurred.
    *
    * @note The write_some operation may not transmit all of the data to the
    * peer. Consider using the @ref write function if you need to ensure that
    * all data is written before the blocking operation completes.
    */
   template <typename ConstBufferSequence>
   std::size_t write_some(const ConstBufferSequence& buffers,
       boost::system::error_code& ec)
   {
-    return this->get_service().write_some(
-        this->get_implementation(), buffers, ec);
+    return this->service.write_some(this->implementation, buffers, ec);
   }
 
   /// Start an asynchronous write.
   /**
    * This function is used to asynchronously write data to the stream handle.
    * The function call always returns immediately.
    *
    * @param buffers One or more data buffers to be written to the handle.
    * 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.
    *
    * @param handler The handler to be called when the write operation completes.
    * Copies will be made of the handler as required. The function signature of
    * the handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
    *   std::size_t bytes_transferred           // Number of bytes written.
    * ); @endcode
    * 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().
    *
    * @note The write operation may not transmit all of the data to the peer.
    * Consider using the @ref async_write function if you need to ensure that all
    * data is written before the asynchronous operation completes.
    *
    * @par Example
    * To write a single data buffer use the @ref buffer function as follows:
    * @code
    * handle.async_write_some(boost::asio::buffer(data, size), handler);
    * @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_MOVE_ARG(WriteHandler) handler)
+      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(),
-        buffers, BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
+    this->service.async_write_some(this->implementation, buffers, handler);
   }
 
   /// Read some data from the handle.
   /**
    * This function is used to read data from the stream handle. The function
    * call will block until one or more bytes of data has been read successfully,
    * or until an error occurs.
    *
    * @param buffers One or more buffers into which the data will be read.
    *
    * @returns The number of bytes read.
    *
    * @throws boost::system::system_error Thrown on failure. An error code of
    * boost::asio::error::eof indicates that the connection was closed by the
    * peer.
    *
    * @note The read_some operation may not read all of the requested number of
    * bytes. Consider using the @ref read function if you need to ensure that
    * the requested amount of data is read before the blocking operation
    * completes.
    *
    * @par Example
    * To read into a single data buffer use the @ref buffer function as follows:
    * @code
    * handle.read_some(boost::asio::buffer(data, size));
    * @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(const MutableBufferSequence& buffers)
   {
     boost::system::error_code ec;
-    std::size_t s = this->get_service().read_some(
-        this->get_implementation(), buffers, ec);
-    boost::asio::detail::throw_error(ec, "read_some");
+    std::size_t s = this->service.read_some(this->implementation, buffers, ec);
+    boost::asio::detail::throw_error(ec);
     return s;
   }
 
   /// Read some data from the handle.
   /**
    * This function is used to read data from the stream handle. The function
    * call will block until one or more bytes of data has been read successfully,
    * or until an error occurs.
    *
    * @param buffers One or more buffers into which the data will be read.
    *
    * @param ec Set to indicate what error occurred, if any.
    *
    * @returns The number of bytes read. Returns 0 if an error occurred.
    *
    * @note The read_some operation may not read all of the requested number of
    * bytes. Consider using the @ref read 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(const MutableBufferSequence& buffers,
       boost::system::error_code& ec)
   {
-    return this->get_service().read_some(
-        this->get_implementation(), buffers, ec);
+    return this->service.read_some(this->implementation, buffers, ec);
   }
 
   /// Start an asynchronous read.
   /**
    * This function is used to asynchronously read data from the stream handle.
    * The function call always returns immediately.
    *
    * @param buffers One or more buffers into which the data will be read.
    * 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.
    *
    * @param handler The handler to be called when the read operation completes.
    * Copies will be made of the handler as required. The function signature of
    * the handler must be:
    * @code void handler(
    *   const boost::system::error_code& error, // Result of operation.
    *   std::size_t bytes_transferred           // Number of bytes read.
    * ); @endcode
    * 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().
    *
    * @note The read operation may not read all of the requested number of bytes.
    * Consider using the @ref async_read function if you need to ensure that the
    * requested amount of data is read before the asynchronous operation
    * completes.
    *
    * @par Example
    * To read into a single data buffer use the @ref buffer function as follows:
    * @code
    * handle.async_read_some(boost::asio::buffer(data, size), handler);
    * @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_MOVE_ARG(ReadHandler) handler)
+      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(),
-        buffers, BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
+    this->service.async_read_some(this->implementation, buffers, handler);
   }
 };
 
 } // namespace windows
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // defined(BOOST_ASIO_HAS_WINDOWS_STREAM_HANDLE)
        //   || defined(GENERATING_DOCUMENTATION)
 
 #endif // BOOST_ASIO_WINDOWS_BASIC_STREAM_HANDLE_HPP
diff --git a/3rdParty/Boost/src/boost/asio/windows/object_handle.hpp b/3rdParty/Boost/src/boost/asio/windows/object_handle.hpp
deleted file mode 100644
index 7bf0654..0000000
--- a/3rdParty/Boost/src/boost/asio/windows/object_handle.hpp
+++ /dev/null
@@ -1,40 +0,0 @@
-//
-// windows/object_handle.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2012 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)
-//
-
-#ifndef BOOST_ASIO_WINDOWS_OBJECT_HANDLE_HPP
-#define BOOST_ASIO_WINDOWS_OBJECT_HANDLE_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_WINDOWS_OBJECT_HANDLE) \
-  || defined(GENERATING_DOCUMENTATION)
-
-#include <boost/asio/windows/basic_object_handle.hpp>
-
-namespace boost {
-namespace asio {
-namespace windows {
-
-/// Typedef for the typical usage of an object handle.
-typedef basic_object_handle<> object_handle;
-
-} // namespace windows
-} // namespace asio
-} // namespace boost
-
-#endif // defined(BOOST_ASIO_HAS_WINDOWS_OBJECT_HANDLE)
-       //   || defined(GENERATING_DOCUMENTATION)
-
-#endif // BOOST_ASIO_WINDOWS_OBJECT_HANDLE_HPP
diff --git a/3rdParty/Boost/src/boost/asio/windows/object_handle_service.hpp b/3rdParty/Boost/src/boost/asio/windows/object_handle_service.hpp
deleted file mode 100644
index ffc89e6..0000000
--- a/3rdParty/Boost/src/boost/asio/windows/object_handle_service.hpp
+++ /dev/null
@@ -1,170 +0,0 @@
-//
-// windows/object_handle_service.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2012 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)
-//
-
-#ifndef BOOST_ASIO_WINDOWS_OBJECT_HANDLE_SERVICE_HPP
-#define BOOST_ASIO_WINDOWS_OBJECT_HANDLE_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_HAS_WINDOWS_OBJECT_HANDLE) \
-  || defined(GENERATING_DOCUMENTATION)
-
-#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>
-
-namespace boost {
-namespace asio {
-namespace windows {
-
-/// Default service implementation for an object handle.
-class object_handle_service
-#if defined(GENERATING_DOCUMENTATION)
-  : public boost::asio::io_service::service
-#else
-  : public boost::asio::detail::service_base<object_handle_service>
-#endif
-{
-public:
-#if defined(GENERATING_DOCUMENTATION)
-  /// The unique service identifier.
-  static boost::asio::io_service::id id;
-#endif
-
-private:
-  // The type of the platform-specific implementation.
-  typedef detail::win_object_handle_service service_impl_type;
-
-public:
-  /// The type of an object handle implementation.
-#if defined(GENERATING_DOCUMENTATION)
-  typedef implementation_defined implementation_type;
-#else
-  typedef service_impl_type::implementation_type implementation_type;
-#endif
-
-  /// The native handle type.
-#if defined(GENERATING_DOCUMENTATION)
-  typedef implementation_defined native_handle_type;
-#else
-  typedef service_impl_type::native_handle_type native_handle_type;
-#endif
-
-  /// Construct a new object handle service for the specified io_service.
-  explicit object_handle_service(boost::asio::io_service& io_service)
-    : boost::asio::detail::service_base<object_handle_service>(io_service),
-      service_impl_(io_service)
-  {
-  }
-
-  /// Construct a new object handle implementation.
-  void construct(implementation_type& impl)
-  {
-    service_impl_.construct(impl);
-  }
-
-#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
-  /// Move-construct a new object handle implementation.
-  void move_construct(implementation_type& impl,
-      implementation_type& other_impl)
-  {
-    service_impl_.move_construct(impl, other_impl);
-  }
-
-  /// Move-assign from another object handle implementation.
-  void move_assign(implementation_type& impl,
-      object_handle_service& other_service,
-      implementation_type& other_impl)
-  {
-    service_impl_.move_assign(impl, other_service.service_impl_, other_impl);
-  }
-#endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
-
-  /// Destroy an object handle implementation.
-  void destroy(implementation_type& impl)
-  {
-    service_impl_.destroy(impl);
-  }
-
-  /// Assign an existing native handle to an object handle.
-  boost::system::error_code assign(implementation_type& impl,
-      const native_handle_type& handle, boost::system::error_code& ec)
-  {
-    return service_impl_.assign(impl, handle, ec);
-  }
-
-  /// Determine whether the handle is open.
-  bool is_open(const implementation_type& impl) const
-  {
-    return service_impl_.is_open(impl);
-  }
-
-  /// Close an object handle implementation.
-  boost::system::error_code close(implementation_type& impl,
-      boost::system::error_code& ec)
-  {
-    return service_impl_.close(impl, ec);
-  }
-
-  /// Get the native handle implementation.
-  native_handle_type native_handle(implementation_type& impl)
-  {
-    return service_impl_.native_handle(impl);
-  }
-
-  /// Cancel all asynchronous operations associated with the handle.
-  boost::system::error_code cancel(implementation_type& impl,
-      boost::system::error_code& ec)
-  {
-    return service_impl_.cancel(impl, ec);
-  }
-
-  // Wait for a signaled state.
-  void wait(implementation_type& impl, boost::system::error_code& ec)
-  {
-    service_impl_.wait(impl, ec);
-  }
-
-  /// Start an asynchronous wait.
-  template <typename WaitHandler>
-  void async_wait(implementation_type& impl,
-      BOOST_ASIO_MOVE_ARG(WaitHandler) handler)
-  {
-    service_impl_.async_wait(impl, BOOST_ASIO_MOVE_CAST(WaitHandler)(handler));
-  }
-
-private:
-  // Destroy all user-defined handler objects owned by the service.
-  void shutdown_service()
-  {
-    service_impl_.shutdown_service();
-  }
-
-  // The platform-specific implementation.
-  service_impl_type service_impl_;
-};
-
-} // namespace windows
-} // namespace asio
-} // namespace boost
-
-#include <boost/asio/detail/pop_options.hpp>
-
-#endif // defined(BOOST_ASIO_HAS_WINDOWS_OBJECT_HANDLE)
-       //   || defined(GENERATING_DOCUMENTATION)
-
-#endif // BOOST_ASIO_WINDOWS_OBJECT_HANDLE_SERVICE_HPP
diff --git a/3rdParty/Boost/src/boost/asio/windows/overlapped_ptr.hpp b/3rdParty/Boost/src/boost/asio/windows/overlapped_ptr.hpp
index 94f9842..c9b1889 100644
--- a/3rdParty/Boost/src/boost/asio/windows/overlapped_ptr.hpp
+++ b/3rdParty/Boost/src/boost/asio/windows/overlapped_ptr.hpp
@@ -1,112 +1,110 @@
 //
 // windows/overlapped_ptr.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_WINDOWS_OVERLAPPED_PTR_HPP
 #define BOOST_ASIO_WINDOWS_OVERLAPPED_PTR_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_WINDOWS_OVERLAPPED_PTR) \
   || defined(GENERATING_DOCUMENTATION)
 
 #include <boost/asio/detail/noncopyable.hpp>
 #include <boost/asio/detail/win_iocp_overlapped_ptr.hpp>
 #include <boost/asio/io_service.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 namespace windows {
 
 /// Wraps a handler to create an OVERLAPPED object for use with overlapped I/O.
 /**
  * A special-purpose smart pointer used to wrap an application handler so that
  * it can be passed as the LPOVERLAPPED argument to overlapped I/O functions.
  *
  * @par Thread Safety
  * @e Distinct @e objects: Safe.@n
  * @e Shared @e objects: Unsafe.
  */
 class overlapped_ptr
   : private noncopyable
 {
 public:
   /// Construct an empty overlapped_ptr.
   overlapped_ptr()
     : impl_()
   {
   }
 
   /// Construct an overlapped_ptr to contain the specified handler.
   template <typename Handler>
-  explicit overlapped_ptr(boost::asio::io_service& io_service,
-      BOOST_ASIO_MOVE_ARG(Handler) handler)
-    : impl_(io_service, BOOST_ASIO_MOVE_CAST(Handler)(handler))
+  explicit overlapped_ptr(boost::asio::io_service& io_service, Handler handler)
+    : impl_(io_service, handler)
   {
   }
 
   /// Destructor automatically frees the OVERLAPPED object unless released.
   ~overlapped_ptr()
   {
   }
 
   /// Reset to empty.
   void reset()
   {
     impl_.reset();
   }
 
   /// Reset to contain the specified handler, freeing any current OVERLAPPED
   /// object.
   template <typename Handler>
-  void reset(boost::asio::io_service& io_service,
-      BOOST_ASIO_MOVE_ARG(Handler) handler)
+  void reset(boost::asio::io_service& io_service, Handler handler)
   {
-    impl_.reset(io_service, BOOST_ASIO_MOVE_CAST(Handler)(handler));
+    impl_.reset(io_service, handler);
   }
 
   /// Get the contained OVERLAPPED object.
   OVERLAPPED* get()
   {
     return impl_.get();
   }
 
   /// Get the contained OVERLAPPED object.
   const OVERLAPPED* get() const
   {
     return impl_.get();
   }
 
   /// Release ownership of the OVERLAPPED object.
   OVERLAPPED* release()
   {
     return impl_.release();
   }
 
   /// Post completion notification for overlapped operation. Releases ownership.
   void complete(const boost::system::error_code& ec,
       std::size_t bytes_transferred)
   {
     impl_.complete(ec, bytes_transferred);
   }
 
 private:
   detail::win_iocp_overlapped_ptr impl_;
 };
 
 } // namespace windows
 } // namespace asio
 } // namespace boost
 
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..183ad0d 100644
--- a/3rdParty/Boost/src/boost/asio/windows/random_access_handle.hpp
+++ b/3rdParty/Boost/src/boost/asio/windows/random_access_handle.hpp
@@ -1,39 +1,39 @@
 //
 // windows/random_access_handle.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_WINDOWS_RANDOM_ACCESS_HANDLE_HPP
 #define BOOST_ASIO_WINDOWS_RANDOM_ACCESS_HANDLE_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_WINDOWS_RANDOM_ACCESS_HANDLE) \
   || defined(GENERATING_DOCUMENTATION)
 
 #include <boost/asio/windows/basic_random_access_handle.hpp>
 
 namespace boost {
 namespace asio {
 namespace windows {
 
 /// Typedef for the typical usage of a random-access handle.
 typedef basic_random_access_handle<> random_access_handle;
 
 } // namespace windows
 } // namespace asio
 } // namespace boost
 
 #endif // defined(BOOST_ASIO_HAS_WINDOWS_RANDOM_ACCESS_HANDLE)
        //   || defined(GENERATING_DOCUMENTATION)
 
 #endif // 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..08cb561 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,208 +1,174 @@
 //
 // windows/random_access_handle_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_WINDOWS_RANDOM_ACCESS_HANDLE_SERVICE_HPP
 #define BOOST_ASIO_WINDOWS_RANDOM_ACCESS_HANDLE_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_HAS_WINDOWS_RANDOM_ACCESS_HANDLE) \
   || defined(GENERATING_DOCUMENTATION)
 
 #include <cstddef>
 #include <boost/config.hpp>
 #include <boost/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>
 
 namespace boost {
 namespace asio {
 namespace windows {
 
 /// Default service implementation for a random-access handle.
 class random_access_handle_service
 #if defined(GENERATING_DOCUMENTATION)
   : public boost::asio::io_service::service
 #else
   : public boost::asio::detail::service_base<random_access_handle_service>
 #endif
 {
 public:
 #if defined(GENERATING_DOCUMENTATION)
   /// The unique service identifier.
   static boost::asio::io_service::id id;
 #endif
 
 private:
   // The type of the platform-specific implementation.
   typedef detail::win_iocp_handle_service service_impl_type;
 
 public:
   /// The type of a random-access handle implementation.
 #if defined(GENERATING_DOCUMENTATION)
   typedef implementation_defined implementation_type;
 #else
   typedef service_impl_type::implementation_type implementation_type;
 #endif
 
-  /// (Deprecated: Use native_handle_type.) The native handle type.
-#if defined(GENERATING_DOCUMENTATION)
-  typedef implementation_defined native_type;
-#else
-  typedef service_impl_type::native_handle_type native_type;
-#endif
-
   /// The native handle type.
 #if defined(GENERATING_DOCUMENTATION)
-  typedef implementation_defined native_handle_type;
+  typedef implementation_defined native_type;
 #else
-  typedef service_impl_type::native_handle_type native_handle_type;
+  typedef service_impl_type::native_type native_type;
 #endif
 
   /// Construct a new random-access handle service for the specified io_service.
   explicit random_access_handle_service(boost::asio::io_service& io_service)
     : boost::asio::detail::service_base<
         random_access_handle_service>(io_service),
       service_impl_(io_service)
   {
   }
 
-  /// Construct a new random-access handle implementation.
-  void construct(implementation_type& impl)
-  {
-    service_impl_.construct(impl);
-  }
-
-#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
-  /// Move-construct a new random-access handle implementation.
-  void move_construct(implementation_type& impl,
-      implementation_type& other_impl)
+  /// Destroy all user-defined handler objects owned by the service.
+  void shutdown_service()
   {
-    service_impl_.move_construct(impl, other_impl);
+    service_impl_.shutdown_service();
   }
 
-  /// Move-assign from another random-access handle implementation.
-  void move_assign(implementation_type& impl,
-      random_access_handle_service& other_service,
-      implementation_type& other_impl)
+  /// Construct a new random-access handle implementation.
+  void construct(implementation_type& impl)
   {
-    service_impl_.move_assign(impl, other_service.service_impl_, other_impl);
+    service_impl_.construct(impl);
   }
-#endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
 
   /// Destroy a random-access handle implementation.
   void destroy(implementation_type& impl)
   {
     service_impl_.destroy(impl);
   }
 
   /// Assign an existing native handle to a random-access handle.
   boost::system::error_code assign(implementation_type& impl,
-      const native_handle_type& handle, boost::system::error_code& ec)
+      const native_type& native_handle, boost::system::error_code& ec)
   {
-    return service_impl_.assign(impl, handle, ec);
+    return service_impl_.assign(impl, native_handle, ec);
   }
 
   /// Determine whether the handle is open.
   bool is_open(const implementation_type& impl) const
   {
     return service_impl_.is_open(impl);
   }
 
   /// Close a random-access handle implementation.
   boost::system::error_code close(implementation_type& impl,
       boost::system::error_code& ec)
   {
     return service_impl_.close(impl, ec);
   }
 
-  /// (Deprecated: Use native_handle().) Get the native handle implementation.
-  native_type native(implementation_type& impl)
-  {
-    return service_impl_.native_handle(impl);
-  }
-
   /// Get the native handle implementation.
-  native_handle_type native_handle(implementation_type& impl)
+  native_type native(implementation_type& impl)
   {
-    return service_impl_.native_handle(impl);
+    return service_impl_.native(impl);
   }
 
   /// Cancel all asynchronous operations associated with the handle.
   boost::system::error_code cancel(implementation_type& impl,
       boost::system::error_code& ec)
   {
     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,
       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_MOVE_ARG(WriteHandler) handler)
+  void async_write_some_at(implementation_type& impl, boost::uint64_t offset,
+      const ConstBufferSequence& buffers, WriteHandler handler)
   {
-    service_impl_.async_write_some_at(impl, offset, buffers,
-        BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
+    service_impl_.async_write_some_at(impl, offset, buffers, handler);
   }
 
   /// Read some data from the specified offset.
   template <typename MutableBufferSequence>
   std::size_t read_some_at(implementation_type& impl, boost::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_MOVE_ARG(ReadHandler) handler)
+  void async_read_some_at(implementation_type& impl, boost::uint64_t offset,
+      const MutableBufferSequence& buffers, ReadHandler handler)
   {
-    service_impl_.async_read_some_at(impl, offset, buffers,
-        BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
+    service_impl_.async_read_some_at(impl, offset, buffers, handler);
   }
 
 private:
-  // Destroy all user-defined handler objects owned by the service.
-  void shutdown_service()
-  {
-    service_impl_.shutdown_service();
-  }
-
   // The platform-specific implementation.
   service_impl_type service_impl_;
 };
 
 } // namespace windows
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // defined(BOOST_ASIO_HAS_WINDOWS_RANDOM_ACCESS_HANDLE)
        //   || defined(GENERATING_DOCUMENTATION)
 
 #endif // BOOST_ASIO_WINDOWS_RANDOM_ACCESS_HANDLE_SERVICE_HPP
diff --git a/3rdParty/Boost/src/boost/asio/windows/stream_handle.hpp b/3rdParty/Boost/src/boost/asio/windows/stream_handle.hpp
index 7d829db..67f6452 100644
--- a/3rdParty/Boost/src/boost/asio/windows/stream_handle.hpp
+++ b/3rdParty/Boost/src/boost/asio/windows/stream_handle.hpp
@@ -1,39 +1,39 @@
 //
 // windows/stream_handle.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_WINDOWS_STREAM_HANDLE_HPP
 #define BOOST_ASIO_WINDOWS_STREAM_HANDLE_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_WINDOWS_STREAM_HANDLE) \
   || defined(GENERATING_DOCUMENTATION)
 
 #include <boost/asio/windows/basic_stream_handle.hpp>
 
 namespace boost {
 namespace asio {
 namespace windows {
 
 /// Typedef for the typical usage of a stream-oriented handle.
 typedef basic_stream_handle<> stream_handle;
 
 } // namespace windows
 } // namespace asio
 } // namespace boost
 
 #endif // defined(BOOST_ASIO_HAS_WINDOWS_STREAM_HANDLE)
        //   || defined(GENERATING_DOCUMENTATION)
 
 #endif // 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..418ea1e 100644
--- a/3rdParty/Boost/src/boost/asio/windows/stream_handle_service.hpp
+++ b/3rdParty/Boost/src/boost/asio/windows/stream_handle_service.hpp
@@ -1,205 +1,171 @@
 //
 // windows/stream_handle_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_WINDOWS_STREAM_HANDLE_SERVICE_HPP
 #define BOOST_ASIO_WINDOWS_STREAM_HANDLE_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_HAS_WINDOWS_STREAM_HANDLE) \
   || defined(GENERATING_DOCUMENTATION)
 
 #include <cstddef>
 #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>
 
 namespace boost {
 namespace asio {
 namespace windows {
 
 /// Default service implementation for a stream handle.
 class stream_handle_service
 #if defined(GENERATING_DOCUMENTATION)
   : public boost::asio::io_service::service
 #else
   : public boost::asio::detail::service_base<stream_handle_service>
 #endif
 {
 public:
 #if defined(GENERATING_DOCUMENTATION)
   /// The unique service identifier.
   static boost::asio::io_service::id id;
 #endif
 
 private:
   // The type of the platform-specific implementation.
   typedef detail::win_iocp_handle_service service_impl_type;
 
 public:
   /// The type of a stream handle implementation.
 #if defined(GENERATING_DOCUMENTATION)
   typedef implementation_defined implementation_type;
 #else
   typedef service_impl_type::implementation_type implementation_type;
 #endif
 
-  /// (Deprecated: Use native_handle_type.) The native handle type.
-#if defined(GENERATING_DOCUMENTATION)
-  typedef implementation_defined native_type;
-#else
-  typedef service_impl_type::native_handle_type native_type;
-#endif
-
   /// The native handle type.
 #if defined(GENERATING_DOCUMENTATION)
-  typedef implementation_defined native_handle_type;
+  typedef implementation_defined native_type;
 #else
-  typedef service_impl_type::native_handle_type native_handle_type;
+  typedef service_impl_type::native_type native_type;
 #endif
 
   /// Construct a new stream handle service for the specified io_service.
   explicit stream_handle_service(boost::asio::io_service& io_service)
     : boost::asio::detail::service_base<stream_handle_service>(io_service),
       service_impl_(io_service)
   {
   }
 
-  /// Construct a new stream handle implementation.
-  void construct(implementation_type& impl)
-  {
-    service_impl_.construct(impl);
-  }
-
-#if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
-  /// Move-construct a new stream handle implementation.
-  void move_construct(implementation_type& impl,
-      implementation_type& other_impl)
+  /// Destroy all user-defined handler objects owned by the service.
+  void shutdown_service()
   {
-    service_impl_.move_construct(impl, other_impl);
+    service_impl_.shutdown_service();
   }
 
-  /// Move-assign from another stream handle implementation.
-  void move_assign(implementation_type& impl,
-      stream_handle_service& other_service,
-      implementation_type& other_impl)
+  /// Construct a new stream handle implementation.
+  void construct(implementation_type& impl)
   {
-    service_impl_.move_assign(impl, other_service.service_impl_, other_impl);
+    service_impl_.construct(impl);
   }
-#endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
 
   /// Destroy a stream handle implementation.
   void destroy(implementation_type& impl)
   {
     service_impl_.destroy(impl);
   }
 
   /// Assign an existing native handle to a stream handle.
   boost::system::error_code assign(implementation_type& impl,
-      const native_handle_type& handle, boost::system::error_code& ec)
+      const native_type& native_handle, boost::system::error_code& ec)
   {
-    return service_impl_.assign(impl, handle, ec);
+    return service_impl_.assign(impl, native_handle, ec);
   }
 
   /// Determine whether the handle is open.
   bool is_open(const implementation_type& impl) const
   {
     return service_impl_.is_open(impl);
   }
 
   /// Close a stream handle implementation.
   boost::system::error_code close(implementation_type& impl,
       boost::system::error_code& ec)
   {
     return service_impl_.close(impl, ec);
   }
 
-  /// (Deprecated: Use native_handle().) Get the native handle implementation.
-  native_type native(implementation_type& impl)
-  {
-    return service_impl_.native_handle(impl);
-  }
-
   /// Get the native handle implementation.
-  native_handle_type native_handle(implementation_type& impl)
+  native_type native(implementation_type& impl)
   {
-    return service_impl_.native_handle(impl);
+    return service_impl_.native(impl);
   }
 
   /// Cancel all asynchronous operations associated with the handle.
   boost::system::error_code cancel(implementation_type& impl,
       boost::system::error_code& ec)
   {
     return service_impl_.cancel(impl, ec);
   }
 
   /// Write the given data to the stream.
   template <typename ConstBufferSequence>
   std::size_t write_some(implementation_type& impl,
       const ConstBufferSequence& buffers, boost::system::error_code& ec)
   {
     return service_impl_.write_some(impl, buffers, ec);
   }
 
   /// Start an asynchronous write.
   template <typename ConstBufferSequence, typename WriteHandler>
   void async_write_some(implementation_type& impl,
-      const ConstBufferSequence& buffers,
-      BOOST_ASIO_MOVE_ARG(WriteHandler) handler)
+      const ConstBufferSequence& buffers, WriteHandler handler)
   {
-    service_impl_.async_write_some(impl, buffers,
-        BOOST_ASIO_MOVE_CAST(WriteHandler)(handler));
+    service_impl_.async_write_some(impl, buffers, handler);
   }
 
   /// 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,
-      const MutableBufferSequence& buffers,
-      BOOST_ASIO_MOVE_ARG(ReadHandler) handler)
+      const MutableBufferSequence& buffers, ReadHandler handler)
   {
-    service_impl_.async_read_some(impl, buffers,
-        BOOST_ASIO_MOVE_CAST(ReadHandler)(handler));
+    service_impl_.async_read_some(impl, buffers, handler);
   }
 
 private:
-  // Destroy all user-defined handler objects owned by the service.
-  void shutdown_service()
-  {
-    service_impl_.shutdown_service();
-  }
-
   // The platform-specific implementation.
   service_impl_type service_impl_;
 };
 
 } // namespace windows
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #endif // defined(BOOST_ASIO_HAS_WINDOWS_STREAM_HANDLE)
        //   || defined(GENERATING_DOCUMENTATION)
 
 #endif // BOOST_ASIO_WINDOWS_STREAM_HANDLE_SERVICE_HPP
diff --git a/3rdParty/Boost/src/boost/asio/write.hpp b/3rdParty/Boost/src/boost/asio/write.hpp
index dd6cb34..537a8d6 100644
--- a/3rdParty/Boost/src/boost/asio/write.hpp
+++ b/3rdParty/Boost/src/boost/asio/write.hpp
@@ -1,148 +1,108 @@
 //
 // write.hpp
 // ~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_WRITE_HPP
 #define BOOST_ASIO_WRITE_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/basic_streambuf_fwd.hpp>
 #include <boost/asio/error.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 
 /**
  * @defgroup write boost::asio::write
  *
  * @brief Write a certain amount of data to a stream before returning.
  */
 /*@{*/
 
 /// 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:
  *
  * @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 stream's
  * write_some function.
  *
  * @param s The stream to which the data is to be written. The type must support
  * the SyncWriteStream concept.
  *
  * @param buffers One or more buffers containing the data to be written. The sum
  * of the buffer sizes indicates the maximum number of bytes to write to the
  * stream.
  *
  * @returns The number of bytes transferred.
  *
  * @throws boost::system::system_error Thrown on failure.
  *
  * @par Example
  * To write a single data buffer use the @ref buffer function as follows:
  * @code boost::asio::write(s, boost::asio::buffer(data, size)); @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.
  *
  * @note This overload is equivalent to calling:
  * @code boost::asio::write(
  *     s, buffers,
  *     boost::asio::transfer_all()); @endcode
  */
 template <typename SyncWriteStream, typename ConstBufferSequence>
 std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers);
 
-/// 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:
- *
- * @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 stream's
- * write_some function.
- *
- * @param s The stream to which the data is to be written. The type must support
- * the SyncWriteStream concept.
- *
- * @param buffers One or more buffers containing the data to be written. The sum
- * of the buffer sizes indicates the maximum number of bytes to write to the
- * stream.
- *
- * @param ec Set to indicate what error occurred, if any.
- *
- * @returns The number of bytes transferred.
- *
- * @par Example
- * To write a single data buffer use the @ref buffer function as follows:
- * @code boost::asio::write(s, boost::asio::buffer(data, size), ec); @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.
- *
- * @note This overload is equivalent to calling:
- * @code boost::asio::write(
- *     s, buffers,
- *     boost::asio::transfer_all(), ec); @endcode
- */
-template <typename SyncWriteStream, typename ConstBufferSequence>
-std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers,
-    boost::system::error_code& ec);
-
 /// Write a certain amount of 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:
  *
  * @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 stream's
  * write_some function.
  *
  * @param s The stream to which the data is to be written. The type must support
  * the SyncWriteStream concept.
  *
  * @param buffers One or more buffers containing the data to be written. The sum
  * of the buffer sizes indicates the maximum number of bytes to write to the
  * stream.
  *
  * @param completion_condition The function object to be called to determine
  * whether the write operation is complete. The signature of the function object
  * must be:
  * @code std::size_t completion_condition(
  *   // Result of latest write_some operation.
  *   const boost::system::error_code& error,
  *
  *   // Number of bytes transferred so far.
  *   std::size_t bytes_transferred
  * ); @endcode
  * A return value of 0 indicates that the write operation is complete. A
  * non-zero return value indicates the maximum number of bytes to be written on
  * the next call to the stream's write_some function.
  *
  * @returns The number of bytes transferred.
@@ -205,100 +165,70 @@ 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)
 
 /// 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:
  *
  * @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 stream's
  * write_some function.
  *
  * @param s The stream to which the data is to be written. The type must support
  * the SyncWriteStream concept.
  *
  * @param b The basic_streambuf object from which data will be written.
  *
  * @returns The number of bytes transferred.
  *
  * @throws boost::system::system_error Thrown on failure.
  *
  * @note This overload is equivalent to calling:
  * @code boost::asio::write(
  *     s, b,
  *     boost::asio::transfer_all()); @endcode
  */
 template <typename SyncWriteStream, typename Allocator>
 std::size_t write(SyncWriteStream& s, basic_streambuf<Allocator>& b);
 
-/// 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:
- *
- * @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 stream's
- * write_some function.
- *
- * @param s The stream to which the data is to be written. The type must support
- * the SyncWriteStream concept.
- *
- * @param b The basic_streambuf object from which data will be written.
- *
- * @param ec Set to indicate what error occurred, if any.
- *
- * @returns The number of bytes transferred.
- *
- * @note This overload is equivalent to calling:
- * @code boost::asio::write(
- *     s, b,
- *     boost::asio::transfer_all(), ec); @endcode
- */
-template <typename SyncWriteStream, typename Allocator>
-std::size_t write(SyncWriteStream& s, basic_streambuf<Allocator>& b,
-    boost::system::error_code& ec);
-
 /// Write a certain amount of 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:
  *
  * @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 stream's
  * write_some function.
  *
  * @param s The stream to which the data is to be written. The type must support
  * the SyncWriteStream concept.
  *
  * @param b The basic_streambuf object from which data will be written.
  *
  * @param completion_condition The function object to be called to determine
  * whether the write operation is complete. The signature of the function object
  * must be:
  * @code std::size_t completion_condition(
  *   // Result of latest write_some operation.
  *   const boost::system::error_code& error,
  *
  *   // Number of bytes transferred so far.
  *   std::size_t bytes_transferred
  * ); @endcode
  * A return value of 0 indicates that the write operation is complete. A
  * non-zero return value indicates the maximum number of bytes to be written on
  * the next call to the stream's write_some function.
  *
  * @returns The number of bytes transferred.
  *
  * @throws boost::system::system_error Thrown on failure.
  */
@@ -382,71 +312,71 @@ std::size_t write(SyncWriteStream& s, basic_streambuf<Allocator>& b,
  * the AsyncWriteStream concept.
  *
  * @param buffers One or more buffers containing the data to be written.
  * 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.
  *
  * @param handler The handler to be called when the write operation completes.
  * Copies will be made of the handler as required. The function signature of
  * the handler must be:
  * @code void handler(
  *   const boost::system::error_code& error, // Result of operation.
  *
  *   std::size_t bytes_transferred           // Number of bytes written from the
  *                                           // buffers. If an error occurred,
  *                                           // this will be less than the sum
  *                                           // of the buffer sizes.
  * ); @endcode
  * 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().
  *
  * @par Example
  * To write a single data buffer use the @ref buffer function as follows:
  * @code
  * boost::asio::async_write(s, boost::asio::buffer(data, size), handler);
  * @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 AsyncWriteStream, typename ConstBufferSequence,
     typename WriteHandler>
 void async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
-    BOOST_ASIO_MOVE_ARG(WriteHandler) handler);
+    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
  * data to a stream. The function call always returns immediately. The
  * asynchronous operation will continue until one of the following conditions
  * is true:
  *
  * @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 stream's
  * async_write_some function, and is known as a <em>composed operation</em>. The
  * program must ensure that the stream performs no other write operations (such
  * as async_write, the stream's async_write_some function, or any other composed
  * operations that perform writes) until this operation completes.
  *
  * @param s The stream to which the data is to be written. The type must support
  * the AsyncWriteStream concept.
  *
  * @param buffers One or more buffers containing the data to be written.
  * 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.
  *
  * @param completion_condition The function object to be called to determine
  * whether the write operation is complete. The signature of the function object
  * must be:
  * @code std::size_t completion_condition(
  *   // Result of latest async_write_some operation.
  *   const boost::system::error_code& error,
  *
@@ -454,158 +384,156 @@ void async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
  *   std::size_t bytes_transferred
  * ); @endcode
  * A return value of 0 indicates that the write operation is complete. A
  * non-zero return value indicates the maximum number of bytes to be written on
  * the next call to the stream's async_write_some function.
  *
  * @param handler The handler to be called when the write operation completes.
  * Copies will be made of the handler as required. The function signature of the
  * handler must be:
  * @code void handler(
  *   const boost::system::error_code& error, // Result of operation.
  *
  *   std::size_t bytes_transferred           // Number of bytes written from the
  *                                           // buffers. If an error occurred,
  *                                           // this will be less than the sum
  *                                           // of the buffer sizes.
  * ); @endcode
  * 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().
  *
  * @par Example
  * To write a single data buffer use the @ref buffer function as follows:
  * @code boost::asio::async_write(s,
  *     boost::asio::buffer(data, size),
  *     boost::asio::transfer_at_least(32),
  *     handler); @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 AsyncWriteStream, typename ConstBufferSequence,
     typename CompletionCondition, typename WriteHandler>
 void async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers,
-    CompletionCondition completion_condition,
-    BOOST_ASIO_MOVE_ARG(WriteHandler) handler);
+    CompletionCondition completion_condition, WriteHandler handler);
 
 #if !defined(BOOST_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
  * asynchronous operation will continue until one of the following conditions
  * is true:
  *
  * @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 stream's
  * async_write_some function, and is known as a <em>composed operation</em>. The
  * program must ensure that the stream performs no other write operations (such
  * as async_write, the stream's async_write_some function, or any other composed
  * operations that perform writes) until this operation completes.
  *
  * @param s The stream to which the data is to be written. The type must support
  * the AsyncWriteStream concept.
  *
  * @param b A basic_streambuf object from which data will be written. Ownership
  * of the streambuf is retained by the caller, which must guarantee that it
  * remains valid until the handler is called.
  *
  * @param handler The handler to be called when the write operation completes.
  * Copies will be made of the handler as required. The function signature of the
  * handler must be:
  * @code void handler(
  *   const boost::system::error_code& error, // Result of operation.
  *
  *   std::size_t bytes_transferred           // Number of bytes written from the
  *                                           // buffers. If an error occurred,
  *                                           // this will be less than the sum
  *                                           // of the buffer sizes.
  * ); @endcode
  * 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_MOVE_ARG(WriteHandler) handler);
+    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
  * data to a stream. The function call always returns immediately. The
  * asynchronous operation will continue until one of the following conditions
  * is true:
  *
  * @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 stream's
  * async_write_some function, and is known as a <em>composed operation</em>. The
  * program must ensure that the stream performs no other write operations (such
  * as async_write, the stream's async_write_some function, or any other composed
  * operations that perform writes) until this operation completes.
  *
  * @param s The stream to which the data is to be written. The type must support
  * the AsyncWriteStream concept.
  *
  * @param b A basic_streambuf object from which data will be written. Ownership
  * of the streambuf is retained by the caller, which must guarantee that it
  * remains valid until the handler is called.
  *
  * @param completion_condition The function object to be called to determine
  * whether the write operation is complete. The signature of the function object
  * must be:
  * @code std::size_t completion_condition(
  *   // Result of latest async_write_some operation.
  *   const boost::system::error_code& error,
  *
  *   // Number of bytes transferred so far.
  *   std::size_t bytes_transferred
  * ); @endcode
  * A return value of 0 indicates that the write operation is complete. A
  * non-zero return value indicates the maximum number of bytes to be written on
  * the next call to the stream's async_write_some function.
  *
  * @param handler The handler to be called when the write operation completes.
  * Copies will be made of the handler as required. The function signature of the
  * handler must be:
  * @code void handler(
  *   const boost::system::error_code& error, // Result of operation.
  *
  *   std::size_t bytes_transferred           // Number of bytes written from the
  *                                           // buffers. If an error occurred,
  *                                           // this will be less than the sum
  *                                           // of the buffer sizes.
  * ); @endcode
  * 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 CompletionCondition, typename WriteHandler>
 void async_write(AsyncWriteStream& s, basic_streambuf<Allocator>& b,
-    CompletionCondition completion_condition,
-    BOOST_ASIO_MOVE_ARG(WriteHandler) handler);
+    CompletionCondition completion_condition, WriteHandler handler);
 
 #endif // !defined(BOOST_NO_IOSTREAM)
 
 /*@}*/
 
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #include <boost/asio/impl/write.hpp>
 
 #endif // BOOST_ASIO_WRITE_HPP
diff --git a/3rdParty/Boost/src/boost/asio/write_at.hpp b/3rdParty/Boost/src/boost/asio/write_at.hpp
index 9535a55..9c0c575 100644
--- a/3rdParty/Boost/src/boost/asio/write_at.hpp
+++ b/3rdParty/Boost/src/boost/asio/write_at.hpp
@@ -1,40 +1,40 @@
 //
 // write_at.hpp
 // ~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// 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_WRITE_AT_HPP
 #define BOOST_ASIO_WRITE_AT_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/cstdint.hpp>
 #include <boost/asio/basic_streambuf_fwd.hpp>
 #include <boost/asio/error.hpp>
 
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
 namespace asio {
 
 /**
  * @defgroup write_at boost::asio::write_at
  *
  * @brief Write a certain amount of data at a specified offset before returning.
  */
 /*@{*/
 
 /// 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:
@@ -44,115 +44,70 @@ namespace asio {
  *
  * @li An error occurred.
  *
  * This operation is implemented in terms of zero or more calls to the device's
  * write_some_at function.
  *
  * @param d The device to which the data is to be written. The type must support
  * the SyncRandomAccessWriteDevice concept.
  *
  * @param offset The offset at which the data will be written.
  *
  * @param buffers One or more buffers containing the data to be written. The sum
  * of the buffer sizes indicates the maximum number of bytes to write to the
  * device.
  *
  * @returns The number of bytes transferred.
  *
  * @throws boost::system::system_error Thrown on failure.
  *
  * @par Example
  * To write a single data buffer use the @ref buffer function as follows:
  * @code boost::asio::write_at(d, 42, boost::asio::buffer(data, size)); @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.
  *
  * @note This overload is equivalent to calling:
  * @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);
 
-/// 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:
- *
- * @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
- * write_some_at function.
- *
- * @param d The device to which the data is to be written. The type must support
- * the SyncRandomAccessWriteDevice concept.
- *
- * @param offset The offset at which the data will be written.
- *
- * @param buffers One or more buffers containing the data to be written. The sum
- * of the buffer sizes indicates the maximum number of bytes to write to the
- * device.
- *
- * @param ec Set to indicate what error occurred, if any.
- *
- * @returns The number of bytes transferred.
- *
- * @par Example
- * To write a single data buffer use the @ref buffer function as follows:
- * @code boost::asio::write_at(d, 42,
- *     boost::asio::buffer(data, size), ec); @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.
- *
- * @note This overload is equivalent to calling:
- * @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,
-    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
  * following conditions is true:
  *
  * @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
  * write_some_at function.
  *
  * @param d The device to which the data is to be written. The type must support
  * the SyncRandomAccessWriteDevice concept.
  *
  * @param offset The offset at which the data will be written.
  *
  * @param buffers One or more buffers containing the data to be written. The sum
  * of the buffer sizes indicates the maximum number of bytes to write to the
  * device.
  *
  * @param completion_condition The function object to be called to determine
  * whether the write operation is complete. The signature of the function object
  * must be:
  * @code std::size_t completion_condition(
  *   // Result of latest write_some_at operation.
  *   const boost::system::error_code& error,
  *
  *   // Number of bytes transferred so far.
  *   std::size_t bytes_transferred
  * ); @endcode
  * A return value of 0 indicates that the write operation is complete. A
  * non-zero return value indicates the maximum number of bytes to be written on
@@ -227,104 +182,70 @@ std::size_t write_at(SyncRandomAccessWriteDevice& d,
 #if !defined(BOOST_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:
  *
  * @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
  * write_some_at function.
  *
  * @param d The device to which the data is to be written. The type must support
  * the SyncRandomAccessWriteDevice concept.
  *
  * @param offset The offset at which the data will be written.
  *
  * @param b The basic_streambuf object from which data will be written.
  *
  * @returns The number of bytes transferred.
  *
  * @throws boost::system::system_error Thrown on failure.
  *
  * @note This overload is equivalent to calling:
  * @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);
 
-/// 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:
- *
- * @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
- * write_some_at function.
- *
- * @param d The device to which the data is to be written. The type must support
- * the SyncRandomAccessWriteDevice concept.
- *
- * @param offset The offset at which the data will be written.
- *
- * @param b The basic_streambuf object from which data will be written.
- *
- * @param ec Set to indicate what error occurred, if any.
- *
- * @returns The number of bytes transferred.
- *
- * @note This overload is equivalent to calling:
- * @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,
-    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
  * following conditions is true:
  *
  * @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
  * write_some_at function.
  *
  * @param d The device to which the data is to be written. The type must support
  * the SyncRandomAccessWriteDevice concept.
  *
  * @param offset The offset at which the data will be written.
  *
  * @param b The basic_streambuf object from which data will be written.
  *
  * @param completion_condition The function object to be called to determine
  * whether the write operation is complete. The signature of the function object
  * must be:
  * @code std::size_t completion_condition(
  *   // Result of latest write_some_at operation.
  *   const boost::system::error_code& error,
  *
  *   // Number of bytes transferred so far.
  *   std::size_t bytes_transferred
  * ); @endcode
  * A return value of 0 indicates that the write operation is complete. A
  * non-zero return value indicates the maximum number of bytes to be written on
  * the next call to the device's write_some_at function.
  *
  * @returns The number of bytes transferred.
@@ -414,72 +335,71 @@ std::size_t write_at(SyncRandomAccessWriteDevice& d, boost::uint64_t offset,
  * @param offset The offset at which the data will be written.
  *
  * @param buffers One or more buffers containing the data to be written.
  * 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.
  *
  * @param handler The handler to be called when the write operation completes.
  * Copies will be made of the handler as required. The function signature of
  * the handler must be:
  * @code void handler(
  *   // Result of operation.
  *   const boost::system::error_code& error,
  *
  *   // Number of bytes written from the buffers. If an error
  *   // occurred, this will be less than the sum of the buffer sizes.
  *   std::size_t bytes_transferred
  * ); @endcode
  * 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().
  *
  * @par Example
  * To write a single data buffer use the @ref buffer function as follows:
  * @code
  * boost::asio::async_write_at(d, 42, boost::asio::buffer(data, size), handler);
  * @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 AsyncRandomAccessWriteDevice, typename ConstBufferSequence,
     typename WriteHandler>
 void async_write_at(AsyncRandomAccessWriteDevice& d, boost::uint64_t offset,
-    const ConstBufferSequence& buffers,
-    BOOST_ASIO_MOVE_ARG(WriteHandler) handler);
+    const ConstBufferSequence& buffers, 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
  * data to a random access device at a specified offset. The function call
  * always returns immediately. The asynchronous operation will continue until
  * one of the following conditions is true:
  *
  * @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.
  *
  * @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.
  *
  * @param buffers One or more buffers containing the data to be written.
  * 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.
  *
  * @param completion_condition The function object to be called to determine
  * whether the write operation is complete. The signature of the function object
  * must be:
  * @code std::size_t completion_condition(
  *   // Result of latest async_write_some_at operation.
  *   const boost::system::error_code& error,
  *
  *   // Number of bytes transferred so far.
@@ -487,157 +407,156 @@ void async_write_at(AsyncRandomAccessWriteDevice& d, boost::uint64_t offset,
  * ); @endcode
  * A return value of 0 indicates that the write operation is complete. A
  * non-zero return value indicates the maximum number of bytes to be written on
  * the next call to the device's async_write_some_at function.
  *
  * @param handler The handler to be called when the write operation completes.
  * Copies will be made of the handler as required. The function signature of the
  * handler must be:
  * @code void handler(
  *   // Result of operation.
  *   const boost::system::error_code& error,
  *
  *   // Number of bytes written from the buffers. If an error
  *   // occurred, this will be less than the sum of the buffer sizes.
  *   std::size_t bytes_transferred
  * ); @endcode
  * 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().
  *
  * @par Example
  * To write a single data buffer use the @ref buffer function as follows:
  * @code boost::asio::async_write_at(d, 42,
  *     boost::asio::buffer(data, size),
  *     boost::asio::transfer_at_least(32),
  *     handler); @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 AsyncRandomAccessWriteDevice, typename ConstBufferSequence,
     typename CompletionCondition, typename WriteHandler>
 void async_write_at(AsyncRandomAccessWriteDevice& d,
     boost::uint64_t offset, const ConstBufferSequence& buffers,
-    CompletionCondition completion_condition,
-    BOOST_ASIO_MOVE_ARG(WriteHandler) handler);
+    CompletionCondition completion_condition, WriteHandler handler);
 
 #if !defined(BOOST_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
  * always returns immediately. The asynchronous operation will continue until
  * one of the following conditions is true:
  *
  * @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.
  *
  * @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.
  *
  * @param b A basic_streambuf object from which data will be written. Ownership
  * of the streambuf is retained by the caller, which must guarantee that it
  * remains valid until the handler is called.
  *
  * @param handler The handler to be called when the write operation completes.
  * Copies will be made of the handler as required. The function signature of the
  * handler must be:
  * @code void handler(
  *   // Result of operation.
  *   const boost::system::error_code& error,
  *
  *   // Number of bytes written from the buffers. If an error
  *   // occurred, this will be less than the sum of the buffer sizes.
  *   std::size_t bytes_transferred
  * ); @endcode
  * 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 AsyncRandomAccessWriteDevice, typename Allocator,
     typename WriteHandler>
 void async_write_at(AsyncRandomAccessWriteDevice& d, boost::uint64_t offset,
-    basic_streambuf<Allocator>& b, BOOST_ASIO_MOVE_ARG(WriteHandler) handler);
+    basic_streambuf<Allocator>& b, 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
  * data to a random access device at a specified offset. The function call
  * always returns immediately. The asynchronous operation will continue until
  * one of the following conditions is true:
  *
  * @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.
  *
  * @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.
  *
  * @param b A basic_streambuf object from which data will be written. Ownership
  * of the streambuf is retained by the caller, which must guarantee that it
  * remains valid until the handler is called.
  *
  * @param completion_condition The function object to be called to determine
  * whether the write operation is complete. The signature of the function object
  * must be:
  * @code std::size_t completion_condition(
  *   // Result of latest async_write_some_at operation.
  *   const boost::system::error_code& error,
  *
  *   // Number of bytes transferred so far.
  *   std::size_t bytes_transferred
  * ); @endcode
  * A return value of 0 indicates that the write operation is complete. A
  * non-zero return value indicates the maximum number of bytes to be written on
  * the next call to the device's async_write_some_at function.
  *
  * @param handler The handler to be called when the write operation completes.
  * Copies will be made of the handler as required. The function signature of the
  * handler must be:
  * @code void handler(
  *   // Result of operation.
  *   const boost::system::error_code& error,
  *
  *   // Number of bytes written from the buffers. If an error
  *   // occurred, this will be less than the sum of the buffer sizes.
  *   std::size_t bytes_transferred
  * ); @endcode
  * 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 AsyncRandomAccessWriteDevice, typename Allocator,
     typename CompletionCondition, typename WriteHandler>
 void async_write_at(AsyncRandomAccessWriteDevice& d, boost::uint64_t offset,
     basic_streambuf<Allocator>& b, CompletionCondition completion_condition,
-    BOOST_ASIO_MOVE_ARG(WriteHandler) handler);
+    WriteHandler handler);
 
 #endif // !defined(BOOST_NO_IOSTREAM)
 
 /*@}*/
 
 } // namespace asio
 } // namespace boost
 
 #include <boost/asio/detail/pop_options.hpp>
 
 #include <boost/asio/impl/write_at.hpp>
 
 #endif // BOOST_ASIO_WRITE_AT_HPP