Fix packet disposing

Source/Managed/ENet.cs

@@ -223,7 +223,7 @@ namespace ENet {
 
 		public void Dispose() {
 			if (nativePacket != IntPtr.Zero) {
-				Native.enet_packet_destroy(nativePacket);
+				Native.enet_packet_dispose(nativePacket);
 				nativePacket = IntPtr.Zero;
 			}
 		}
@@ -686,7 +686,7 @@ namespace ENet {
 		public const uint timeoutLimit = 32;
 		public const uint timeoutMinimum = 5000;
 		public const uint timeoutMaximum = 30000;
-		public const uint version = (2 << 16) | (0 << 8) | (8);
+		public const uint version = (2 << 16) | (0 << 8) | (9);
 
 		public static int Initialize() {
 			return Native.enet_initialize();
@@ -745,7 +745,7 @@ namespace ENet {
 		internal static extern void enet_packet_set_free_callback(IntPtr packet, IntPtr callback);
 
 		[DllImport(nativeLibrary, CallingConvention = CallingConvention.Cdecl)]
-		internal static extern void enet_packet_destroy(IntPtr packet);
+		internal static extern void enet_packet_dispose(IntPtr packet);
 
 		[DllImport(nativeLibrary, CallingConvention = CallingConvention.Cdecl)]
 		internal static extern IntPtr enet_host_create(ref ENetAddress address, IntPtr peerLimit, IntPtr channelLimit, uint incomingBandwidth, uint outgoingBandwidth);
@@ -852,4 +852,4 @@ namespace ENet {
 		[DllImport(nativeLibrary, CallingConvention = CallingConvention.Cdecl)]
 		internal static extern void enet_peer_reset(IntPtr peer);
 	}
-}
+}

Source/Native/enet.h

@@ -1,5438 +1,5445 @@
-/*
- *  ENet reliable UDP networking library 
- *  Copyright (c) 2018 Lee Salzman, Vladyslav Hrytsenko, Dominik Madarász, Stanislav Denisov
- *
- *  Permission is hereby granted, free of charge, to any person obtaining a copy
- *  of this software and associated documentation files (the "Software"), to deal
- *  in the Software without restriction, including without limitation the rights
- *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- *  copies of the Software, and to permit persons to whom the Software is
- *  furnished to do so, subject to the following conditions:
- *
- *  The above copyright notice and this permission notice shall be included in all
- *  copies or substantial portions of the Software.
- *
- *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- *  SOFTWARE.
- */
-
-#ifndef ENET_INCLUDE_H
-#define ENET_INCLUDE_H
-
-#include <stdlib.h>
-#include <stdbool.h>
-#include <stdint.h>
-#include <time.h>
-
-#define ENET_VERSION_MAJOR 2
-#define ENET_VERSION_MINOR 0
-#define ENET_VERSION_PATCH 8
-#define ENET_VERSION_CREATE(major, minor, patch) (((major)<<16) | ((minor)<<8) | (patch))
-#define ENET_VERSION_GET_MAJOR(version) (((version)>>16)&0xFF)
-#define ENET_VERSION_GET_MINOR(version) (((version)>>8)&0xFF)
-#define ENET_VERSION_GET_PATCH(version) ((version)&0xFF)
-#define ENET_VERSION ENET_VERSION_CREATE(ENET_VERSION_MAJOR, ENET_VERSION_MINOR, ENET_VERSION_PATCH)
-
-#define ENET_TIME_OVERFLOW 86400000
-#define ENET_TIME_LESS(a, b) ((a) - (b) >= ENET_TIME_OVERFLOW)
-#define ENET_TIME_GREATER(a, b) ((b) - (a) >= ENET_TIME_OVERFLOW)
-#define ENET_TIME_LESS_EQUAL(a, b) (! ENET_TIME_GREATER (a, b))
-#define ENET_TIME_GREATER_EQUAL(a, b) (! ENET_TIME_LESS (a, b))
-#define ENET_TIME_DIFFERENCE(a, b) ((a) - (b) >= ENET_TIME_OVERFLOW ? (b) - (a) : (a) - (b))
-
-// =======================================================================//
-// !
-// ! System differences
-// !
-// =======================================================================//
-
-#if defined(_WIN32)
-    #if defined(_MSC_VER) && defined(ENET_IMPLEMENTATION)
-        #pragma warning (disable: 4267) /* size_t to int conversion */
-        #pragma warning (disable: 4244) /* 64bit to 32bit int */
-        #pragma warning (disable: 4018) /* signed/unsigned mismatch */
-        #pragma warning (disable: 4146) /* unary minus operator applied to unsigned type */
-    #endif
-
-    #ifndef ENET_NO_PRAGMA_LINK
-        #pragma comment(lib, "ws2_32.lib")
-        #pragma comment(lib, "winmm.lib")
-    #endif
-
-    #if _MSC_VER >= 1910
-        /* It looks like there were changes as of Visual Studio 2017 and there are no 32/64 bit
-           versions of _InterlockedExchange[operation], only InterlockedExchange[operation]
-           (without leading underscore), so we have to distinguish between compiler versions */
-        #define NOT_UNDERSCORED_INTERLOCKED_EXCHANGE
-    #endif
-
-    #ifdef __GNUC__
-        #if (_WIN32_WINNT < 0x0501)
-            #undef _WIN32_WINNT
-            #define _WIN32_WINNT 0x0501
-        #endif
-    #endif
-
-    #include <winsock2.h>
-    #include <ws2tcpip.h>
-    #include <mmsystem.h>
-    #include <intrin.h>
-
-    #if defined(_WIN32) && defined(_MSC_VER)
-        #if _MSC_VER < 1900
-            typedef struct timespec {
-                long tv_sec;
-                long tv_nsec;
-            };
-        #endif
-        #define CLOCK_MONOTONIC 0
-    #endif
-
-    typedef SOCKET ENetSocket;
-    #define ENET_SOCKET_NULL INVALID_SOCKET
-
-    #define ENET_HOST_TO_NET_16(value) (htons(value))
-    #define ENET_HOST_TO_NET_32(value) (htonl(value))
-
-    #define ENET_NET_TO_HOST_16(value) (ntohs(value))
-    #define ENET_NET_TO_HOST_32(value) (ntohl(value))
-
-    typedef struct {
-        size_t dataLength;
-        void * data;
-    } ENetBuffer;
-
-    #define ENET_CALLBACK __cdecl
-
-    #ifdef ENET_DLL
-        #ifdef ENET_IMPLEMENTATION
-            #define ENET_API __declspec(dllexport)
-        #else
-            #define ENET_API __declspec(dllimport)
-        #endif
-    #else
-        #define ENET_API extern
-    #endif
-
-    typedef fd_set ENetSocketSet;
-
-    #define ENET_SOCKETSET_EMPTY(sockset)          FD_ZERO(&(sockset))
-    #define ENET_SOCKETSET_ADD(sockset, socket)    FD_SET(socket, &(sockset))
-    #define ENET_SOCKETSET_REMOVE(sockset, socket) FD_CLR(socket, &(sockset))
-    #define ENET_SOCKETSET_CHECK(sockset, socket)  FD_ISSET(socket, &(sockset))
-#else
-    #include <sys/types.h>
-    #include <sys/ioctl.h>
-    #include <sys/time.h>
-    #include <sys/socket.h>
-    #include <poll.h>
-    #include <arpa/inet.h>
-    #include <netinet/in.h>
-    #include <netinet/tcp.h>
-    #include <netdb.h>
-    #include <unistd.h>
-    #include <string.h>
-    #include <errno.h>
-    #include <fcntl.h>
-
-    #ifdef __APPLE__
-        #include <mach/clock.h>
-        #include <mach/mach.h>
-        #include <Availability.h>
-    #endif
-
-    #ifndef MSG_NOSIGNAL
-        #define MSG_NOSIGNAL 0
-    #endif
-
-    #ifdef MSG_MAXIOVLEN
-        #define ENET_BUFFER_MAXIMUM MSG_MAXIOVLEN
-    #endif
-
-    typedef int ENetSocket;
-
-    #define ENET_SOCKET_NULL -1
-
-    #define ENET_HOST_TO_NET_16(value) (htons(value))
-    #define ENET_HOST_TO_NET_32(value) (htonl(value))
-
-    #define ENET_NET_TO_HOST_16(value) (ntohs(value))
-    #define ENET_NET_TO_HOST_32(value) (ntohl(value))
-
-    typedef struct {
-        void * data;
-        size_t dataLength;
-    } ENetBuffer;
-
-    #define ENET_CALLBACK
-    #define ENET_API extern
-
-    typedef fd_set ENetSocketSet;
-
-    #define ENET_SOCKETSET_EMPTY(sockset)          FD_ZERO(&(sockset))
-    #define ENET_SOCKETSET_ADD(sockset, socket)    FD_SET(socket, &(sockset))
-    #define ENET_SOCKETSET_REMOVE(sockset, socket) FD_CLR(socket, &(sockset))
-    #define ENET_SOCKETSET_CHECK(sockset, socket)  FD_ISSET(socket, &(sockset))
-#endif
-
-#ifndef ENET_BUFFER_MAXIMUM
-    #define ENET_BUFFER_MAXIMUM (1 + 2 * ENET_PROTOCOL_MAXIMUM_PACKET_COMMANDS)
-#endif
-
-#define ENET_MAX(x, y) ((x) > (y) ? (x) : (y))
-#define ENET_MIN(x, y) ((x) < (y) ? (x) : (y))
-#define ENET_IPV6           1
-#define ENET_HOST_ANY       in6addr_any
-#define ENET_HOST_BROADCAST 0xFFFFFFFFU
-#define ENET_PORT_ANY       0
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-// =======================================================================//
-// !
-// ! Basic stuff
-// !
-// =======================================================================//
-
-    typedef uint8_t   enet_uint8;
-    typedef uint16_t enet_uint16;
-    typedef uint32_t enet_uint32;
-    typedef uint64_t enet_uint64;
-
-    typedef enet_uint32 ENetVersion;
-
-    typedef struct _ENetCallbacks {
-        void *(ENET_CALLBACK *malloc) (size_t size);
-        void (ENET_CALLBACK *free) (void *memory);
-        void (ENET_CALLBACK *no_memory) (void);
-    } ENetCallbacks;
-
-    extern void *enet_malloc(size_t);
-    extern void enet_free(void *);
-
-// =======================================================================//
-// !
-// ! List
-// !
-// =======================================================================//
-
-    typedef struct _ENetListNode {
-        struct _ENetListNode *next;
-        struct _ENetListNode *previous;
-    } ENetListNode;
-
-    typedef ENetListNode *ENetListIterator;
-
-    typedef struct _ENetList {
-        ENetListNode sentinel;
-    } ENetList;
-
-    extern ENetListIterator enet_list_insert(ENetListIterator, void *);
-    extern ENetListIterator enet_list_move(ENetListIterator, void *, void *);
-
-    extern void *enet_list_remove(ENetListIterator);
-    extern void enet_list_clear(ENetList *);
-    extern size_t enet_list_size(ENetList *);
-
-    #define enet_list_begin(list) ((list)->sentinel.next)
-    #define enet_list_end(list) (&(list)->sentinel)
-    #define enet_list_empty(list) (enet_list_begin(list) == enet_list_end(list))
-    #define enet_list_next(iterator) ((iterator)->next)
-    #define enet_list_previous(iterator) ((iterator)->previous)
-    #define enet_list_front(list) ((void *) (list)->sentinel.next)
-    #define enet_list_back(list) ((void *) (list)->sentinel.previous)
-
-// =======================================================================//
-// !
-// ! Protocol
-// !
-// =======================================================================//
-
-    enum {
-        ENET_PROTOCOL_MINIMUM_MTU             = 576,
-        ENET_PROTOCOL_MAXIMUM_MTU             = 4096,
-        ENET_PROTOCOL_MAXIMUM_PACKET_COMMANDS = 32,
-        ENET_PROTOCOL_MINIMUM_WINDOW_SIZE     = 4096,
-        ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE     = 65536,
-        ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT   = 1,
-        ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT   = 255,
-        ENET_PROTOCOL_MAXIMUM_PEER_ID         = 0xFFF,
-        ENET_PROTOCOL_MAXIMUM_FRAGMENT_COUNT  = 1024 * 1024
-    };
-
-    typedef enum _ENetProtocolCommand {
-        ENET_PROTOCOL_COMMAND_NONE                     = 0,
-        ENET_PROTOCOL_COMMAND_ACKNOWLEDGE              = 1,
-        ENET_PROTOCOL_COMMAND_CONNECT                  = 2,
-        ENET_PROTOCOL_COMMAND_VERIFY_CONNECT           = 3,
-        ENET_PROTOCOL_COMMAND_DISCONNECT               = 4,
-        ENET_PROTOCOL_COMMAND_PING                     = 5,
-        ENET_PROTOCOL_COMMAND_SEND_RELIABLE            = 6,
-        ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE          = 7,
-        ENET_PROTOCOL_COMMAND_SEND_FRAGMENT            = 8,
-        ENET_PROTOCOL_COMMAND_SEND_UNSEQUENCED         = 9,
-        ENET_PROTOCOL_COMMAND_BANDWIDTH_LIMIT          = 10,
-        ENET_PROTOCOL_COMMAND_THROTTLE_CONFIGURE       = 11,
-        ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE_FRAGMENT = 12,
-        ENET_PROTOCOL_COMMAND_COUNT                    = 13,
-        ENET_PROTOCOL_COMMAND_MASK                     = 0x0F
-    } ENetProtocolCommand;
-
-    typedef enum _ENetProtocolFlag {
-        ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE = (1 << 7),
-        ENET_PROTOCOL_COMMAND_FLAG_UNSEQUENCED = (1 << 6),
-        ENET_PROTOCOL_HEADER_FLAG_SENT_TIME    = (1 << 14),
-        ENET_PROTOCOL_HEADER_FLAG_MASK         = ENET_PROTOCOL_HEADER_FLAG_SENT_TIME,
-        ENET_PROTOCOL_HEADER_SESSION_MASK      = (3 << 12),
-        ENET_PROTOCOL_HEADER_SESSION_SHIFT     = 12
-    } ENetProtocolFlag;
-
-    #ifdef _MSC_VER
-        #pragma pack(push, 1)
-        #define ENET_PACKED
-    #elif defined(__GNUC__) || defined(__clang__)
-        #define ENET_PACKED __attribute__ ((packed))
-    #else
-        #define ENET_PACKED
-    #endif
-
-    typedef struct _ENetProtocolHeader {
-        enet_uint16 peerID;
-        enet_uint16 sentTime;
-    } ENET_PACKED ENetProtocolHeader;
-
-    typedef struct _ENetProtocolCommandHeader {
-        enet_uint8  command;
-        enet_uint8  channelID;
-        enet_uint16 reliableSequenceNumber;
-    } ENET_PACKED ENetProtocolCommandHeader;
-
-    typedef struct _ENetProtocolAcknowledge {
-        ENetProtocolCommandHeader header;
-        enet_uint16               receivedReliableSequenceNumber;
-        enet_uint16               receivedSentTime;
-    } ENET_PACKED ENetProtocolAcknowledge;
-
-    typedef struct _ENetProtocolConnect {
-        ENetProtocolCommandHeader header;
-        enet_uint16               outgoingPeerID;
-        enet_uint8                incomingSessionID;
-        enet_uint8                outgoingSessionID;
-        enet_uint32               mtu;
-        enet_uint32               windowSize;
-        enet_uint32               channelCount;
-        enet_uint32               incomingBandwidth;
-        enet_uint32               outgoingBandwidth;
-        enet_uint32               packetThrottleInterval;
-        enet_uint32               packetThrottleAcceleration;
-        enet_uint32               packetThrottleDeceleration;
-        enet_uint32               connectID;
-        enet_uint32               data;
-    } ENET_PACKED ENetProtocolConnect;
-
-    typedef struct _ENetProtocolVerifyConnect {
-        ENetProtocolCommandHeader header;
-        enet_uint16               outgoingPeerID;
-        enet_uint8                incomingSessionID;
-        enet_uint8                outgoingSessionID;
-        enet_uint32               mtu;
-        enet_uint32               windowSize;
-        enet_uint32               channelCount;
-        enet_uint32               incomingBandwidth;
-        enet_uint32               outgoingBandwidth;
-        enet_uint32               packetThrottleInterval;
-        enet_uint32               packetThrottleAcceleration;
-        enet_uint32               packetThrottleDeceleration;
-        enet_uint32               connectID;
-    } ENET_PACKED ENetProtocolVerifyConnect;
-
-    typedef struct _ENetProtocolBandwidthLimit {
-        ENetProtocolCommandHeader header;
-        enet_uint32               incomingBandwidth;
-        enet_uint32               outgoingBandwidth;
-    } ENET_PACKED ENetProtocolBandwidthLimit;
-
-    typedef struct _ENetProtocolThrottleConfigure {
-        ENetProtocolCommandHeader header;
-        enet_uint32               packetThrottleInterval;
-        enet_uint32               packetThrottleAcceleration;
-        enet_uint32               packetThrottleDeceleration;
-    } ENET_PACKED ENetProtocolThrottleConfigure;
-
-    typedef struct _ENetProtocolDisconnect {
-        ENetProtocolCommandHeader header;
-        enet_uint32               data;
-    } ENET_PACKED ENetProtocolDisconnect;
-
-    typedef struct _ENetProtocolPing {
-        ENetProtocolCommandHeader header;
-    } ENET_PACKED ENetProtocolPing;
-
-    typedef struct _ENetProtocolSendReliable {
-        ENetProtocolCommandHeader header;
-        enet_uint16               dataLength;
-    } ENET_PACKED ENetProtocolSendReliable;
-
-    typedef struct _ENetProtocolSendUnreliable {
-        ENetProtocolCommandHeader header;
-        enet_uint16               unreliableSequenceNumber;
-        enet_uint16               dataLength;
-    } ENET_PACKED ENetProtocolSendUnreliable;
-
-    typedef struct _ENetProtocolSendUnsequenced {
-        ENetProtocolCommandHeader header;
-        enet_uint16               unsequencedGroup;
-        enet_uint16               dataLength;
-    } ENET_PACKED ENetProtocolSendUnsequenced;
-
-    typedef struct _ENetProtocolSendFragment {
-        ENetProtocolCommandHeader header;
-        enet_uint16               startSequenceNumber;
-        enet_uint16               dataLength;
-        enet_uint32               fragmentCount;
-        enet_uint32               fragmentNumber;
-        enet_uint32               totalLength;
-        enet_uint32               fragmentOffset;
-    } ENET_PACKED ENetProtocolSendFragment;
-
-    typedef union _ENetProtocol {
-        ENetProtocolCommandHeader     header;
-        ENetProtocolAcknowledge       acknowledge;
-        ENetProtocolConnect           connect;
-        ENetProtocolVerifyConnect     verifyConnect;
-        ENetProtocolDisconnect        disconnect;
-        ENetProtocolPing              ping;
-        ENetProtocolSendReliable      sendReliable;
-        ENetProtocolSendUnreliable    sendUnreliable;
-        ENetProtocolSendUnsequenced   sendUnsequenced;
-        ENetProtocolSendFragment      sendFragment;
-        ENetProtocolBandwidthLimit    bandwidthLimit;
-        ENetProtocolThrottleConfigure throttleConfigure;
-    } ENET_PACKED ENetProtocol;
-
-    #ifdef _MSC_VER
-        #pragma pack(pop)
-    #endif
-
-// =======================================================================//
-// !
-// ! General ENet structs/enums
-// !
-// =======================================================================//
-
-    typedef enum _ENetSocketType {
-        ENET_SOCKET_TYPE_STREAM   = 1,
-        ENET_SOCKET_TYPE_DATAGRAM = 2
-    } ENetSocketType;
-
-    typedef enum _ENetSocketWait {
-        ENET_SOCKET_WAIT_NONE      = 0,
-        ENET_SOCKET_WAIT_SEND      = (1 << 0),
-        ENET_SOCKET_WAIT_RECEIVE   = (1 << 1),
-        ENET_SOCKET_WAIT_INTERRUPT = (1 << 2)
-    } ENetSocketWait;
-
-    typedef enum _ENetSocketOption {
-        ENET_SOCKOPT_NONBLOCK  = 1,
-        ENET_SOCKOPT_BROADCAST = 2,
-        ENET_SOCKOPT_RCVBUF    = 3,
-        ENET_SOCKOPT_SNDBUF    = 4,
-        ENET_SOCKOPT_REUSEADDR = 5,
-        ENET_SOCKOPT_RCVTIMEO  = 6,
-        ENET_SOCKOPT_SNDTIMEO  = 7,
-        ENET_SOCKOPT_ERROR     = 8,
-        ENET_SOCKOPT_NODELAY   = 9,
-        ENET_SOCKOPT_IPV6_V6ONLY = 10,
-    } ENetSocketOption;
-
-    typedef enum _ENetSocketShutdown {
-        ENET_SOCKET_SHUTDOWN_READ       = 0,
-        ENET_SOCKET_SHUTDOWN_WRITE      = 1,
-        ENET_SOCKET_SHUTDOWN_READ_WRITE = 2
-    } ENetSocketShutdown;
-
-    typedef struct _ENetAddress {
-        struct in6_addr host;
-        enet_uint16 port;
-        enet_uint16 sin6_scope_id;
-    } ENetAddress;
-
-    #define in6_equal(in6_addr_a, in6_addr_b) (memcmp(&in6_addr_a, &in6_addr_b, sizeof(struct in6_addr)) == 0)
-
-    typedef enum _ENetPacketFlag {
-        ENET_PACKET_FLAG_RELIABLE            = (1 << 0),
-        ENET_PACKET_FLAG_UNSEQUENCED         = (1 << 1),
-        ENET_PACKET_FLAG_NO_ALLOCATE         = (1 << 2),
-        ENET_PACKET_FLAG_UNRELIABLE_FRAGMENT = (1 << 3),
-        ENET_PACKET_FLAG_SENT                = (1 << 8),
-    } ENetPacketFlag;
-
-    typedef void (ENET_CALLBACK *ENetPacketFreeCallback) (void *);
-
-    typedef struct _ENetPacket {
-        size_t                 referenceCount;
-        enet_uint32            flags;
-        enet_uint8 *           data;
-        size_t                 dataLength;
-        ENetPacketFreeCallback freeCallback;
-        void *                 userData;
-    } ENetPacket;
-
-    typedef struct _ENetAcknowledgement {
-        ENetListNode acknowledgementList;
-        enet_uint32  sentTime;
-        ENetProtocol command;
-    } ENetAcknowledgement;
-
-    typedef struct _ENetOutgoingCommand {
-        ENetListNode outgoingCommandList;
-        enet_uint16  reliableSequenceNumber;
-        enet_uint16  unreliableSequenceNumber;
-        enet_uint32  sentTime;
-        enet_uint32  roundTripTimeout;
-        enet_uint32  roundTripTimeoutLimit;
-        enet_uint32  fragmentOffset;
-        enet_uint16  fragmentLength;
-        enet_uint16  sendAttempts;
-        ENetProtocol command;
-        ENetPacket * packet;
-    } ENetOutgoingCommand;
-
-    typedef struct _ENetIncomingCommand {
-        ENetListNode incomingCommandList;
-        enet_uint16  reliableSequenceNumber;
-        enet_uint16  unreliableSequenceNumber;
-        ENetProtocol command;
-        enet_uint32  fragmentCount;
-        enet_uint32  fragmentsRemaining;
-        enet_uint32 *fragments;
-        ENetPacket * packet;
-    } ENetIncomingCommand;
-
-    typedef enum _ENetPeerState {
-        ENET_PEER_STATE_DISCONNECTED             = 0,
-        ENET_PEER_STATE_CONNECTING               = 1,
-        ENET_PEER_STATE_ACKNOWLEDGING_CONNECT    = 2,
-        ENET_PEER_STATE_CONNECTION_PENDING       = 3,
-        ENET_PEER_STATE_CONNECTION_SUCCEEDED     = 4,
-        ENET_PEER_STATE_CONNECTED                = 5,
-        ENET_PEER_STATE_DISCONNECT_LATER         = 6,
-        ENET_PEER_STATE_DISCONNECTING            = 7,
-        ENET_PEER_STATE_ACKNOWLEDGING_DISCONNECT = 8,
-        ENET_PEER_STATE_ZOMBIE                   = 9
-    } ENetPeerState;
-
-    enum {
-        ENET_HOST_RECEIVE_BUFFER_SIZE          = 256 * 1024,
-        ENET_HOST_SEND_BUFFER_SIZE             = 256 * 1024,
-        ENET_HOST_BANDWIDTH_THROTTLE_INTERVAL  = 1000,
-        ENET_HOST_DEFAULT_MTU                  = 1400,
-        ENET_HOST_DEFAULT_MAXIMUM_PACKET_SIZE  = 32 * 1024 * 1024,
-        ENET_HOST_DEFAULT_MAXIMUM_WAITING_DATA = 32 * 1024 * 1024,
-        ENET_PEER_DEFAULT_ROUND_TRIP_TIME      = 500,
-        ENET_PEER_DEFAULT_PACKET_THROTTLE      = 32,
-        ENET_PEER_PACKET_THROTTLE_SCALE        = 32,
-        ENET_PEER_PACKET_THROTTLE_COUNTER      = 7,
-        ENET_PEER_PACKET_THROTTLE_ACCELERATION = 2,
-        ENET_PEER_PACKET_THROTTLE_DECELERATION = 2,
-        ENET_PEER_PACKET_THROTTLE_INTERVAL     = 5000,
-        ENET_PEER_PACKET_LOSS_SCALE            = (1 << 16),
-        ENET_PEER_PACKET_LOSS_INTERVAL         = 10000,
-        ENET_PEER_WINDOW_SIZE_SCALE            = 64 * 1024,
-        ENET_PEER_TIMEOUT_LIMIT                = 32,
-        ENET_PEER_TIMEOUT_MINIMUM              = 5000,
-        ENET_PEER_TIMEOUT_MAXIMUM              = 30000,
-        ENET_PEER_PING_INTERVAL                = 500,
-        ENET_PEER_UNSEQUENCED_WINDOWS          = 64,
-        ENET_PEER_UNSEQUENCED_WINDOW_SIZE      = 1024,
-        ENET_PEER_FREE_UNSEQUENCED_WINDOWS     = 32,
-        ENET_PEER_RELIABLE_WINDOWS             = 16,
-        ENET_PEER_RELIABLE_WINDOW_SIZE         = 0x1000,
-        ENET_PEER_FREE_RELIABLE_WINDOWS        = 8
-    };
-
-    typedef struct _ENetChannel {
-        enet_uint16 outgoingReliableSequenceNumber;
-        enet_uint16 outgoingUnreliableSequenceNumber;
-        enet_uint16 usedReliableWindows;
-        enet_uint16 reliableWindows[ENET_PEER_RELIABLE_WINDOWS];
-        enet_uint16 incomingReliableSequenceNumber;
-        enet_uint16 incomingUnreliableSequenceNumber;
-        ENetList    incomingReliableCommands;
-        ENetList    incomingUnreliableCommands;
-    } ENetChannel;
-
-    typedef struct _ENetPeer {
-        ENetListNode      dispatchList;
-        struct _ENetHost *host;
-        enet_uint16       outgoingPeerID;
-        enet_uint16       incomingPeerID;
-        enet_uint32       connectID;
-        enet_uint8        outgoingSessionID;
-        enet_uint8        incomingSessionID;
-        ENetAddress       address;
-        void *            data;
-        ENetPeerState     state;
-        ENetChannel *     channels;
-        size_t            channelCount;
-        enet_uint32       incomingBandwidth;
-        enet_uint32       outgoingBandwidth;
-        enet_uint32       incomingBandwidthThrottleEpoch;
-        enet_uint32       outgoingBandwidthThrottleEpoch;
-        enet_uint32       incomingDataTotal;
-        enet_uint64       totalDataReceived;
-        enet_uint32       outgoingDataTotal;
-        enet_uint64       totalDataSent;
-        enet_uint32       lastSendTime;
-        enet_uint32       lastReceiveTime;
-        enet_uint32       nextTimeout;
-        enet_uint32       earliestTimeout;
-        enet_uint32       packetLossEpoch;
-        enet_uint32       packetsSent;
-        enet_uint64       totalPacketsSent;
-        enet_uint32       packetsLost;
-        enet_uint32       totalPacketsLost;
-        enet_uint32       packetLoss;
-        enet_uint32       packetLossVariance;
-        enet_uint32       packetThrottle;
-        enet_uint32       packetThrottleLimit;
-        enet_uint32       packetThrottleCounter;
-        enet_uint32       packetThrottleEpoch;
-        enet_uint32       packetThrottleAcceleration;
-        enet_uint32       packetThrottleDeceleration;
-        enet_uint32       packetThrottleInterval;
-        enet_uint32       pingInterval;
-        enet_uint32       timeoutLimit;
-        enet_uint32       timeoutMinimum;
-        enet_uint32       timeoutMaximum;
-        enet_uint32       lastRoundTripTime;
-        enet_uint32       lowestRoundTripTime;
-        enet_uint32       lastRoundTripTimeVariance;
-        enet_uint32       highestRoundTripTimeVariance;
-        enet_uint32       roundTripTime;
-        enet_uint32       roundTripTimeVariance;
-        enet_uint32       mtu;
-        enet_uint32       windowSize;
-        enet_uint32       reliableDataInTransit;
-        enet_uint16       outgoingReliableSequenceNumber;
-        ENetList          acknowledgements;
-        ENetList          sentReliableCommands;
-        ENetList          sentUnreliableCommands;
-        ENetList          outgoingReliableCommands;
-        ENetList          outgoingUnreliableCommands;
-        ENetList          dispatchedCommands;
-        int               needsDispatch;
-        enet_uint16       incomingUnsequencedGroup;
-        enet_uint16       outgoingUnsequencedGroup;
-        enet_uint32       unsequencedWindow[ENET_PEER_UNSEQUENCED_WINDOW_SIZE / 32];
-        enet_uint32       eventData;
-        size_t            totalWaitingData;
-    } ENetPeer;
-
-    typedef enet_uint32 (ENET_CALLBACK * ENetChecksumCallback) (const ENetBuffer *buffers, size_t bufferCount);
-
-    typedef int (ENET_CALLBACK * ENetInterceptCallback) (struct _ENetHost *host, void *event);
-
-    typedef struct _ENetHost {
-        ENetSocket            socket;
-        ENetAddress           address;
-        enet_uint32           incomingBandwidth;
-        enet_uint32           outgoingBandwidth;
-        enet_uint32           bandwidthThrottleEpoch;
-        enet_uint32           mtu;
-        enet_uint32           randomSeed;
-        int                   recalculateBandwidthLimits;
-        ENetPeer *            peers;
-        size_t                peerCount;
-        size_t                channelLimit;
-        enet_uint32           serviceTime;
-        ENetList              dispatchQueue;
-        int                   continueSending;
-        size_t                packetSize;
-        enet_uint16           headerFlags;
-        enet_uint32           totalSentData;
-        enet_uint32           totalSentPackets;
-        enet_uint32           totalReceivedData;
-        enet_uint32           totalReceivedPackets;
-        ENetProtocol          commands[ENET_PROTOCOL_MAXIMUM_PACKET_COMMANDS];
-        size_t                commandCount;
-        ENetBuffer            buffers[ENET_BUFFER_MAXIMUM];
-        size_t                bufferCount;
-        ENetChecksumCallback  checksum;
-        enet_uint8            packetData[2][ENET_PROTOCOL_MAXIMUM_MTU];
-        ENetAddress           receivedAddress;
-        enet_uint8 *          receivedData;
-        size_t                receivedDataLength;
-        ENetInterceptCallback intercept;
-        size_t                connectedPeers;
-        size_t                bandwidthLimitedPeers;
-        size_t                duplicatePeers;
-        size_t                maximumPacketSize;
-        size_t                maximumWaitingData;
-    } ENetHost;
-
-    typedef enum _ENetEventType {
-        ENET_EVENT_TYPE_NONE       = 0,
-        ENET_EVENT_TYPE_CONNECT    = 1,
-        ENET_EVENT_TYPE_DISCONNECT = 2,
-        ENET_EVENT_TYPE_RECEIVE    = 3,
-        ENET_EVENT_TYPE_DISCONNECT_TIMEOUT = 4,
-    } ENetEventType;
-
-    typedef struct _ENetEvent {
-        ENetEventType type;
-        ENetPeer *    peer;
-        enet_uint8    channelID;
-        enet_uint32   data;
-        ENetPacket *  packet;
-    } ENetEvent;
-
-// =======================================================================//
-// !
-// ! Public API
-// !
-// =======================================================================//
-
-    ENET_API int                 enet_initialize (void);
-    ENET_API int                 enet_initialize_with_callbacks (ENetVersion version, const ENetCallbacks * inits);
-    ENET_API void                enet_deinitialize (void);
-    ENET_API ENetVersion         enet_linked_version (void);
-    ENET_API enet_uint32         enet_time_get (void);
-
-    ENET_API ENetSocket          enet_socket_create(ENetSocketType);
-    ENET_API int                 enet_socket_bind(ENetSocket, const ENetAddress *);
-    ENET_API int                 enet_socket_get_address(ENetSocket, ENetAddress *);
-    ENET_API int                 enet_socket_listen(ENetSocket, int);
-    ENET_API ENetSocket          enet_socket_accept(ENetSocket, ENetAddress *);
-    ENET_API int                 enet_socket_connect(ENetSocket, const ENetAddress *);
-    ENET_API int                 enet_socket_send(ENetSocket, const ENetAddress *, const ENetBuffer *, size_t);
-    ENET_API int                 enet_socket_receive(ENetSocket, ENetAddress *, ENetBuffer *, size_t);
-    ENET_API int                 enet_socket_wait(ENetSocket, enet_uint32 *, enet_uint64);
-    ENET_API int                 enet_socket_set_option(ENetSocket, ENetSocketOption, int);
-    ENET_API int                 enet_socket_get_option(ENetSocket, ENetSocketOption, int *);
-    ENET_API int                 enet_socket_shutdown(ENetSocket, ENetSocketShutdown);
-    ENET_API void                enet_socket_destroy(ENetSocket);
-    ENET_API int                 enet_socketset_select(ENetSocket, ENetSocketSet *, ENetSocketSet *, enet_uint32);
-
-    ENET_API int                 enet_address_set_host_ip (ENetAddress * address, const char * hostName);
-    ENET_API int                 enet_address_set_host (ENetAddress * address, const char * hostName);
-    ENET_API int                 enet_address_get_host_ip (const ENetAddress * address, char * hostName, size_t nameLength);
-    ENET_API int                 enet_address_get_host (const ENetAddress * address, char * hostName, size_t nameLength);
-
-    ENET_API ENetPacket *        enet_packet_create (const void *, size_t, enet_uint32);
-    ENET_API ENetPacket *        enet_packet_create_offset (const void *, size_t, size_t, enet_uint32);
-    ENET_API void                enet_packet_destroy (ENetPacket *);
-
-    ENET_API enet_uint32         enet_crc32 (const ENetBuffer *, size_t);
-
-    ENET_API ENetHost *          enet_host_create (const ENetAddress *, size_t, size_t, enet_uint32, enet_uint32);
-    ENET_API void                enet_host_destroy (ENetHost *);
-    ENET_API ENetPeer *          enet_host_connect (ENetHost *, const ENetAddress *, size_t, enet_uint32);
-    ENET_API int                 enet_host_check_events (ENetHost *, ENetEvent *);
-    ENET_API int                 enet_host_service (ENetHost *, ENetEvent *, enet_uint32);
-    ENET_API void                enet_host_flush (ENetHost *);
-    ENET_API void                enet_host_broadcast (ENetHost *, enet_uint8, ENetPacket *);
-    ENET_API void                enet_host_channel_limit (ENetHost *, size_t);
-    ENET_API void                enet_host_bandwidth_limit (ENetHost *, enet_uint32, enet_uint32);
-    extern   void                enet_host_bandwidth_throttle (ENetHost *);
-    extern  enet_uint64          enet_host_random_seed (void);
-
-    ENET_API int                 enet_peer_send (ENetPeer *, enet_uint8, ENetPacket *);
-    ENET_API ENetPacket *        enet_peer_receive (ENetPeer *, enet_uint8 * channelID);
-    ENET_API void                enet_peer_ping (ENetPeer *);
-    ENET_API void                enet_peer_ping_interval (ENetPeer *, enet_uint32);
-    ENET_API void                enet_peer_timeout (ENetPeer *, enet_uint32, enet_uint32, enet_uint32);
-    ENET_API void                enet_peer_reset (ENetPeer *);
-    ENET_API void                enet_peer_disconnect (ENetPeer *, enet_uint32);
-    ENET_API void                enet_peer_disconnect_now (ENetPeer *, enet_uint32);
-    ENET_API void                enet_peer_disconnect_later (ENetPeer *, enet_uint32);
-    ENET_API void                enet_peer_throttle_configure (ENetPeer *, enet_uint32, enet_uint32, enet_uint32);
-    extern int                   enet_peer_throttle (ENetPeer *, enet_uint32);
-    extern void                  enet_peer_reset_queues (ENetPeer *);
-    extern void                  enet_peer_setup_outgoing_command (ENetPeer *, ENetOutgoingCommand *);
-    extern ENetOutgoingCommand * enet_peer_queue_outgoing_command (ENetPeer *, const ENetProtocol *, ENetPacket *, enet_uint32, enet_uint16);
-    extern ENetIncomingCommand * enet_peer_queue_incoming_command (ENetPeer *, const ENetProtocol *, const void *, size_t, enet_uint32, enet_uint32);
-    extern ENetAcknowledgement * enet_peer_queue_acknowledgement (ENetPeer *, const ENetProtocol *, enet_uint16);
-    extern void                  enet_peer_dispatch_incoming_unreliable_commands (ENetPeer *, ENetChannel *);
-    extern void                  enet_peer_dispatch_incoming_reliable_commands (ENetPeer *, ENetChannel *);
-    extern void                  enet_peer_on_connect (ENetPeer *);
-    extern void                  enet_peer_on_disconnect (ENetPeer *);
-
-    extern size_t                enet_protocol_command_size (enet_uint8);
-
-    /* Extended API for easier binding in other programming languages */
-    ENET_API void *              enet_packet_get_data (ENetPacket *);
-    ENET_API int                 enet_packet_get_length (ENetPacket *);
-    ENET_API void                enet_packet_set_free_callback (ENetPacket *, const void *);
-
-    ENET_API enet_uint32         enet_host_get_peers_count (ENetHost *);
-    ENET_API enet_uint32         enet_host_get_packets_sent (ENetHost *);
-    ENET_API enet_uint32         enet_host_get_packets_received (ENetHost *);
-    ENET_API enet_uint32         enet_host_get_bytes_sent (ENetHost *);
-    ENET_API enet_uint32         enet_host_get_bytes_received (ENetHost *);
-
-    ENET_API enet_uint32         enet_peer_get_id (ENetPeer *);
-    ENET_API int                 enet_peer_get_ip (ENetPeer *, char * ip, size_t ipLength);
-    ENET_API enet_uint16         enet_peer_get_port (ENetPeer *);
-    ENET_API ENetPeerState       enet_peer_get_state (ENetPeer *);
-    ENET_API enet_uint32         enet_peer_get_rtt (ENetPeer *);
-    ENET_API enet_uint64         enet_peer_get_packets_sent (ENetPeer *);
-    ENET_API enet_uint32         enet_peer_get_packets_lost (ENetPeer *);
-    ENET_API enet_uint64         enet_peer_get_bytes_sent (ENetPeer *);
-    ENET_API enet_uint64         enet_peer_get_bytes_received (ENetPeer *);
-    ENET_API void *              enet_peer_get_data (ENetPeer *);
-    ENET_API void                enet_peer_set_data (ENetPeer *, const void *);
-
-#ifdef __cplusplus
-}
-#endif
-
-#if defined(ENET_IMPLEMENTATION) && !defined(ENET_IMPLEMENTATION_DONE)
-#define ENET_IMPLEMENTATION_DONE 1
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-// =======================================================================//
-// !
-// ! Atomics
-// !
-// =======================================================================//
-
-#if defined(_MSC_VER)
-    #define ENET_AT_CASSERT_PRED(predicate) sizeof(char[2 * !!(predicate)-1])
-    #define ENET_IS_SUPPORTED_ATOMIC(size) ENET_AT_CASSERT_PRED(size == 1 || size == 2 || size == 4 || size == 8)
-    #define ENET_ATOMIC_SIZEOF(variable) (ENET_IS_SUPPORTED_ATOMIC(sizeof(*(variable))), sizeof(*(variable)))
-
-    __inline int64_t enet_at_atomic_read(char *ptr, size_t size) {
-        switch (size) {
-            case 1:
-                return _InterlockedExchangeAdd8((volatile char *)ptr, 0);
-
-            case 2:
-                return _InterlockedExchangeAdd16((volatile SHORT *)ptr, 0);
-
-            case 4:
-                #ifdef NOT_UNDERSCORED_INTERLOCKED_EXCHANGE
-                    return InterlockedExchangeAdd((volatile LONG *)ptr, 0);
-                #else
-                    return _InterlockedExchangeAdd((volatile LONG *)ptr, 0);
-                #endif
-
-            case 8:
-                #ifdef NOT_UNDERSCORED_INTERLOCKED_EXCHANGE
-                    return InterlockedExchangeAdd64((volatile LONGLONG *)ptr, 0);
-                #else
-                    return _InterlockedExchangeAdd64((volatile LONGLONG *)ptr, 0);
-                #endif
-
-            default:
-                return 0x0;
-        }
-    }
-
-    __inline int64_t enet_at_atomic_write(char *ptr, int64_t value, size_t size) {
-        switch (size) {
-            case 1:
-                return _InterlockedExchange8((volatile char *)ptr, (char)value);
-
-            case 2:
-                return _InterlockedExchange16((volatile SHORT *)ptr, (SHORT)value);
-
-            case 4:
-                #ifdef NOT_UNDERSCORED_INTERLOCKED_EXCHANGE
-                    return InterlockedExchange((volatile LONG *)ptr, (LONG)value);
-                #else
-                    return _InterlockedExchange((volatile LONG *)ptr, (LONG)value);
-                #endif
-
-            case 8:
-                #ifdef NOT_UNDERSCORED_INTERLOCKED_EXCHANGE
-                    return InterlockedExchange64((volatile LONGLONG *)ptr, (LONGLONG)value);
-                #else
-                    return _InterlockedExchange64((volatile LONGLONG *)ptr, (LONGLONG)value);
-                #endif
-
-            default:
-                return 0x0;
-        }
-    }
-
-    __inline int64_t enet_at_atomic_cas(char *ptr, int64_t new_val, int64_t old_val, size_t size) {
-        switch (size) {
-            case 1:
-                return _InterlockedCompareExchange8((volatile char *)ptr, (char)new_val, (char)old_val);
-
-            case 2:
-                return _InterlockedCompareExchange16((volatile SHORT *)ptr, (SHORT)new_val,
-                                                     (SHORT)old_val);
-            case 4:
-                #ifdef NOT_UNDERSCORED_INTERLOCKED_EXCHANGE
-                    return InterlockedCompareExchange((volatile LONG *)ptr, (LONG)new_val, (LONG)old_val);
-                #else
-                    return _InterlockedCompareExchange((volatile LONG *)ptr, (LONG)new_val, (LONG)old_val);
-                #endif
-
-            case 8:
-                #ifdef NOT_UNDERSCORED_INTERLOCKED_EXCHANGE
-                    return InterlockedCompareExchange64((volatile LONGLONG *)ptr, (LONGLONG)new_val, (LONGLONG)old_val);
-                #else
-                    return _InterlockedCompareExchange64((volatile LONGLONG *)ptr, (LONGLONG)new_val, (LONGLONG)old_val);
-                #endif
-
-            default:
-                return 0x0;
-        }
-    }
-
-    __inline int64_t enet_at_atomic_inc(char *ptr, int64_t delta, size_t data_size) {
-        switch (data_size) {
-            case 1:
-                return _InterlockedExchangeAdd8((volatile char *)ptr, (char)delta);
-
-            case 2:
-                return _InterlockedExchangeAdd16((volatile SHORT *)ptr, (SHORT)delta);
-
-            case 4:
-                #ifdef NOT_UNDERSCORED_INTERLOCKED_EXCHANGE
-                    return InterlockedExchangeAdd((volatile LONG *)ptr, (LONG)delta);
-                #else
-                    return _InterlockedExchangeAdd((volatile LONG *)ptr, (LONG)delta);
-                #endif
-
-            case 8:
-                #ifdef NOT_UNDERSCORED_INTERLOCKED_EXCHANGE
-                    return InterlockedExchangeAdd64((volatile LONGLONG *)ptr, (LONGLONG)delta);
-                #else
-                    return _InterlockedExchangeAdd64((volatile LONGLONG *)ptr, (LONGLONG)delta);
-                #endif
-
-            default:
-                return 0x0;
-        }
-    }
-
-    #define ENET_ATOMIC_READ(variable) enet_at_atomic_read((char *) (variable), ENET_ATOMIC_SIZEOF(variable))
-    #define ENET_ATOMIC_WRITE(variable, new_val)                                                                 \
-        enet_at_atomic_write((char *) (variable), (int64_t) (new_val), ENET_ATOMIC_SIZEOF(variable))
-    #define ENET_ATOMIC_CAS(variable, old_value, new_val)                                                        \
-        enet_at_atomic_cas((char *) (variable), (int64_t) (new_val), (int64_t) (old_value),                         \
-                      ENET_ATOMIC_SIZEOF(variable))
-    #define ENET_ATOMIC_INC(variable) enet_at_atomic_inc((char *) (variable), 1, ENET_ATOMIC_SIZEOF(variable))
-    #define ENET_ATOMIC_DEC(variable) enet_at_atomic_inc((char *) (variable), -1, ENET_ATOMIC_SIZEOF(variable))
-    #define ENET_ATOMIC_INC_BY(variable, delta)                                                                  \
-        enet_at_atomic_inc((char *) (variable), (delta), ENET_ATOMIC_SIZEOF(variable))
-    #define ENET_ATOMIC_DEC_BY(variable, delta)                                                                  \
-        enet_at_atomic_inc((char *) (variable), -(delta), ENET_ATOMIC_SIZEOF(variable))
-#elif defined(__GNUC__) || defined(__clang__)
-    #if defined(__clang__) || (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7))
-        #define AT_HAVE_ATOMICS
-    #endif
-
-    /* We want to use __atomic built-ins if possible because the __sync primitives are
-       deprecated, because the __atomic build-ins allow us to use ENET_ATOMIC_WRITE on
-       uninitialized memory without running into undefined behavior, and because the
-       __atomic versions generate more efficient code since we don't need to rely on
-       CAS when we don't actually want it.
-
-       Note that we use acquire-release memory order (like mutexes do). We could use
-       sequentially consistent memory order but that has lower performance and is
-       almost always unneeded. */
-    #ifdef AT_HAVE_ATOMICS
-        #define ENET_ATOMIC_READ(ptr) __atomic_load_n((ptr), __ATOMIC_ACQUIRE)
-        #define ENET_ATOMIC_WRITE(ptr, value) __atomic_store_n((ptr), (value), __ATOMIC_RELEASE)
-
-        #ifndef typeof
-            #define typeof __typeof__
-        #endif
-
-        /* clang_analyzer doesn't know that CAS writes to memory so it complains about
-           potentially lost data. Replace the code with the equivalent non-sync code. */
-        #ifdef __clang_analyzer__
-            #define ENET_ATOMIC_CAS(ptr, old_value, new_value)                                                      \
-                ({                                                                                                  \
-                    typeof(*(ptr)) ENET_ATOMIC_CAS_old_actual_ = (*(ptr));                                          \
-                    if (ATOMIC_CAS_old_actual_ == (old_value)) {                                                    \
-                        *(ptr) = new_value;                                                                         \
-                    }                                                                                               \
-                    ENET_ATOMIC_CAS_old_actual_;                                                                    \
-                })
-            #else
-            /* Could use __auto_type instead of typeof but that shouldn't work in C++.
-               The ({ }) syntax is a GCC extension called statement expression. It lets
-               us return a value out of the macro.
-
-               TODO We should return bool here instead of the old value to avoid the ABA
-               problem. */
-            #define ENET_ATOMIC_CAS(ptr, old_value, new_value)                                                      \
-                ({                                                                                                  \
-                    typeof(*(ptr)) ENET_ATOMIC_CAS_expected_ = (old_value);                                         \
-                    __atomic_compare_exchange_n((ptr), &ENET_ATOMIC_CAS_expected_, (new_value), false,              \
-                                                __ATOMIC_ACQ_REL, __ATOMIC_ACQUIRE);                                \
-                    ENET_ATOMIC_CAS_expected_;                                                                      \
-                })
-            #endif
-
-            #define ENET_ATOMIC_INC(ptr) __atomic_fetch_add((ptr), 1, __ATOMIC_ACQ_REL)
-            #define ENET_ATOMIC_DEC(ptr) __atomic_fetch_sub((ptr), 1, __ATOMIC_ACQ_REL)
-            #define ENET_ATOMIC_INC_BY(ptr, delta) __atomic_fetch_add((ptr), (delta), __ATOMIC_ACQ_REL)
-            #define ENET_ATOMIC_DEC_BY(ptr, delta) __atomic_fetch_sub((ptr), (delta), __ATOMIC_ACQ_REL)
-        #else
-            #define ENET_ATOMIC_READ(variable) __sync_fetch_and_add(variable, 0)
-            #define ENET_ATOMIC_WRITE(variable, new_val)                                                            \
-                (void) __sync_val_compare_and_swap((variable), *(variable), (new_val))
-            #define ENET_ATOMIC_CAS(variable, old_value, new_val)                                                   \
-                __sync_val_compare_and_swap((variable), (old_value), (new_val))
-            #define ENET_ATOMIC_INC(variable) __sync_fetch_and_add((variable), 1)
-            #define ENET_ATOMIC_DEC(variable) __sync_fetch_and_sub((variable), 1)
-            #define ENET_ATOMIC_INC_BY(variable, delta) __sync_fetch_and_add((variable), (delta), 1)
-            #define ENET_ATOMIC_DEC_BY(variable, delta) __sync_fetch_and_sub((variable), (delta), 1)
-    #endif
-    #undef AT_HAVE_ATOMICS
-#endif
-
-// =======================================================================//
-// !
-// ! Callbacks
-// !
-// =======================================================================//
-
-    static ENetCallbacks callbacks = { malloc, free, abort };
-
-    int enet_initialize_with_callbacks(ENetVersion version, const ENetCallbacks *inits) {
-        if (version < ENET_VERSION_CREATE(1, 3, 0)) {
-            return -1;
-        }
-
-        if (inits->malloc != NULL || inits->free != NULL) {
-            if (inits->malloc == NULL || inits->free == NULL) {
-                return -1;
-            }
-
-            callbacks.malloc = inits->malloc;
-            callbacks.free   = inits->free;
-        }
-
-        if (inits->no_memory != NULL) {
-            callbacks.no_memory = inits->no_memory;
-        }
-
-        return enet_initialize();
-    }
-
-    ENetVersion enet_linked_version(void) {
-        return ENET_VERSION;
-    }
-
-    void *enet_malloc(size_t size) {
-        void *memory = callbacks.malloc(size);
-
-        if (memory == NULL) {
-            callbacks.no_memory();
-        }
-
-        return memory;
-    }
-
-    void enet_free(void *memory) {
-        callbacks.free(memory);
-    }
-
-// =======================================================================//
-// !
-// ! List
-// !
-// =======================================================================//
-
-    void enet_list_clear(ENetList *list) {
-        list->sentinel.next     = &list->sentinel;
-        list->sentinel.previous = &list->sentinel;
-    }
-
-    ENetListIterator enet_list_insert(ENetListIterator position, void *data) {
-        ENetListIterator result = (ENetListIterator)data;
-
-        result->previous = position->previous;
-        result->next     = position;
-
-        result->previous->next = result;
-        position->previous     = result;
-
-        return result;
-    }
-
-    void *enet_list_remove(ENetListIterator position) {
-        position->previous->next = position->next;
-        position->next->previous = position->previous;
-
-        return position;
-    }
-
-    ENetListIterator enet_list_move(ENetListIterator position, void *dataFirst, void *dataLast) {
-        ENetListIterator first = (ENetListIterator)dataFirst;
-        ENetListIterator last  = (ENetListIterator)dataLast;
-
-        first->previous->next = last->next;
-        last->next->previous  = first->previous;
-
-        first->previous = position->previous;
-        last->next      = position;
-
-        first->previous->next = first;
-        position->previous    = last;
-
-        return first;
-    }
-
-    size_t enet_list_size(ENetList *list) {
-        size_t size = 0;
-        ENetListIterator position;
-
-        for (position = enet_list_begin(list); position != enet_list_end(list); position = enet_list_next(position)) {
-            ++size;
-        }
-
-        return size;
-    }
-
-// =======================================================================//
-// !
-// ! Packet
-// !
-// =======================================================================//
-
-    ENetPacket *enet_packet_create(const void *data, size_t dataLength, enet_uint32 flags) {
-        ENetPacket *packet;
-
-        if (flags & ENET_PACKET_FLAG_NO_ALLOCATE) {
-            packet = (ENetPacket *)enet_malloc(sizeof(ENetPacket));
-
-            if (packet == NULL) {
-                return NULL;
-            }
-
-            packet->data = (enet_uint8 *)data;
-        } else {
-            packet = (ENetPacket *)enet_malloc(sizeof(ENetPacket) + dataLength);
-
-            if (packet == NULL) {
-                return NULL;
-            }
-
-            packet->data = (enet_uint8 *)packet + sizeof(ENetPacket);
-
-            if (data != NULL) {
-                memcpy(packet->data, data, dataLength);
-            }
-        }
-
-        packet->referenceCount = 0;
-        packet->flags        = flags;
-        packet->dataLength   = dataLength;
-        packet->freeCallback = NULL;
-        packet->userData     = NULL;
-
-        return packet;
-    }
-
-    ENetPacket *enet_packet_create_offset(const void *data, size_t dataLength, size_t dataOffset, enet_uint32 flags) {
-        ENetPacket *packet;
-
-        if (flags & ENET_PACKET_FLAG_NO_ALLOCATE) {
-            packet = (ENetPacket *)enet_malloc(sizeof(ENetPacket));
-
-            if (packet == NULL) {
-                return NULL;
-            }
-
-            packet->data = (enet_uint8 *)data;
-        } else {
-            packet = (ENetPacket *)enet_malloc(sizeof(ENetPacket) + dataLength + dataOffset);
-
-            if (packet == NULL) {
-                return NULL;
-            }
-
-            packet->data = (enet_uint8 *)packet + sizeof(ENetPacket);
-
-            if (data != NULL) {
-                memcpy(packet->data + dataOffset, data, dataLength);
-            }
-        }
-
-        packet->referenceCount = 0;
-        packet->flags        = flags;
-        packet->dataLength   = dataLength + dataOffset;
-        packet->freeCallback = NULL;
-        packet->userData     = NULL;
-
-        return packet;
-    }
-
-    void enet_packet_destroy(ENetPacket *packet) {
-        if (packet == NULL) {
-            return;
-        }
-
-        if (packet->freeCallback != NULL) {
-            (*packet->freeCallback) ((void *)packet);
-        }
-
-        enet_free(packet);
-    }
-
-    static int initializedCRC32 = 0;
-    static enet_uint32 crcTable[256];
-
-    static enet_uint32 reflect_crc(int val, int bits) {
-        int result = 0, bit;
-
-        for (bit = 0; bit < bits; bit++) {
-            if (val & 1) { result |= 1 << (bits - 1 - bit); }
-            val >>= 1;
-        }
-
-        return result;
-    }
-
-    static void initialize_crc32(void) {
-        int byte;
-
-        for (byte = 0; byte < 256; ++byte) {
-            enet_uint32 crc = reflect_crc(byte, 8) << 24;
-            int offset;
-
-            for (offset = 0; offset < 8; ++offset) {
-                if (crc & 0x80000000) {
-                    crc = (crc << 1) ^ 0x04c11db7;
-                } else {
-                    crc <<= 1;
-                }
-            }
-
-            crcTable[byte] = reflect_crc(crc, 32);
-        }
-
-        initializedCRC32 = 1;
-    }
-
-    enet_uint32 enet_crc32(const ENetBuffer *buffers, size_t bufferCount) {
-        enet_uint32 crc = 0xFFFFFFFF;
-
-        if (!initializedCRC32) { initialize_crc32(); }
-
-        while (bufferCount-- > 0) {
-            const enet_uint8 *data = (const enet_uint8 *)buffers->data;
-            const enet_uint8 *dataEnd = &data[buffers->dataLength];
-
-            while (data < dataEnd) {
-                crc = (crc >> 8) ^ crcTable[(crc & 0xFF) ^ *data++];
-            }
-
-            ++buffers;
-        }
-
-        return ENET_HOST_TO_NET_32(~crc);
-    }
-
-// =======================================================================//
-// !
-// ! Protocol
-// !
-// =======================================================================//
-
-    static size_t commandSizes[ENET_PROTOCOL_COMMAND_COUNT] = {
-        0,
-        sizeof(ENetProtocolAcknowledge),
-        sizeof(ENetProtocolConnect),
-        sizeof(ENetProtocolVerifyConnect),
-        sizeof(ENetProtocolDisconnect),
-        sizeof(ENetProtocolPing),
-        sizeof(ENetProtocolSendReliable),
-        sizeof(ENetProtocolSendUnreliable),
-        sizeof(ENetProtocolSendFragment),
-        sizeof(ENetProtocolSendUnsequenced),
-        sizeof(ENetProtocolBandwidthLimit),
-        sizeof(ENetProtocolThrottleConfigure),
-        sizeof(ENetProtocolSendFragment)
-    };
-
-    size_t enet_protocol_command_size(enet_uint8 commandNumber) {
-        return commandSizes[commandNumber & ENET_PROTOCOL_COMMAND_MASK];
-    }
-
-    static void enet_protocol_change_state(ENetHost *host, ENetPeer *peer, ENetPeerState state) {
-        if (state == ENET_PEER_STATE_CONNECTED || state == ENET_PEER_STATE_DISCONNECT_LATER) {
-            enet_peer_on_connect(peer);
-        } else {
-            enet_peer_on_disconnect(peer);
-        }
-
-        peer->state = state;
-    }
-
-    static void enet_protocol_dispatch_state(ENetHost *host, ENetPeer *peer, ENetPeerState state) {
-        enet_protocol_change_state(host, peer, state);
-
-        if (!peer->needsDispatch) {
-            enet_list_insert(enet_list_end(&host->dispatchQueue), &peer->dispatchList);
-            peer->needsDispatch = 1;
-        }
-    }
-
-    static int enet_protocol_dispatch_incoming_commands(ENetHost *host, ENetEvent *event) {
-        while (!enet_list_empty(&host->dispatchQueue)) {
-            ENetPeer *peer = (ENetPeer *)enet_list_remove(enet_list_begin(&host->dispatchQueue));
-            peer->needsDispatch = 0;
-
-            switch (peer->state) {
-                case ENET_PEER_STATE_CONNECTION_PENDING:
-                case ENET_PEER_STATE_CONNECTION_SUCCEEDED:
-                    enet_protocol_change_state(host, peer, ENET_PEER_STATE_CONNECTED);
-
-                    event->type = ENET_EVENT_TYPE_CONNECT;
-                    event->peer = peer;
-                    event->data = peer->eventData;
-
-                    return 1;
-
-                case ENET_PEER_STATE_ZOMBIE:
-                    host->recalculateBandwidthLimits = 1;
-
-                    event->type = ENET_EVENT_TYPE_DISCONNECT;
-                    event->peer = peer;
-                    event->data = peer->eventData;
-
-                    enet_peer_reset(peer);
-
-                    return 1;
-
-                case ENET_PEER_STATE_CONNECTED:
-                    if (enet_list_empty(&peer->dispatchedCommands)) {
-                        continue;
-                    }
-
-                    event->packet = enet_peer_receive(peer, &event->channelID);
-                    if (event->packet == NULL) {
-                        continue;
-                    }
-
-                    event->type = ENET_EVENT_TYPE_RECEIVE;
-                    event->peer = peer;
-
-                    if (!enet_list_empty(&peer->dispatchedCommands)) {
-                        peer->needsDispatch = 1;
-                        enet_list_insert(enet_list_end(&host->dispatchQueue), &peer->dispatchList);
-                    }
-
-                    return 1;
-
-                default:
-                    break;
-            }
-        }
-
-        return 0;
-    }
-
-    static void enet_protocol_notify_connect(ENetHost *host, ENetPeer *peer, ENetEvent *event) {
-        host->recalculateBandwidthLimits = 1;
-
-        if (event != NULL) {
-            enet_protocol_change_state(host, peer, ENET_PEER_STATE_CONNECTED);
-
-            peer->totalDataSent     = 0;
-            peer->totalDataReceived = 0;
-            peer->totalPacketsSent  = 0;
-            peer->totalPacketsLost  = 0;
-            event->type = ENET_EVENT_TYPE_CONNECT;
-            event->peer = peer;
-            event->data = peer->eventData;
-        } else {
-            enet_protocol_dispatch_state(host, peer, peer->state == ENET_PEER_STATE_CONNECTING ? ENET_PEER_STATE_CONNECTION_SUCCEEDED : ENET_PEER_STATE_CONNECTION_PENDING);
-        }
-    }
-
-    static void enet_protocol_notify_disconnect(ENetHost *host, ENetPeer *peer, ENetEvent *event) {
-        if (peer->state >= ENET_PEER_STATE_CONNECTION_PENDING) {
-            host->recalculateBandwidthLimits = 1;
-        }
-
-        if (peer->state != ENET_PEER_STATE_CONNECTING && peer->state < ENET_PEER_STATE_CONNECTION_SUCCEEDED) {
-            enet_peer_reset(peer);
-        } else if (event != NULL) {
-            event->type = ENET_EVENT_TYPE_DISCONNECT;
-            event->peer = peer;
-            event->data = 0;
-
-            enet_peer_reset(peer);
-        } else {
-            peer->eventData = 0;
-            enet_protocol_dispatch_state(host, peer, ENET_PEER_STATE_ZOMBIE);
-        }
-    }
-
-    static void enet_protocol_notify_disconnect_timeout (ENetHost * host, ENetPeer * peer, ENetEvent * event) {
-        if (peer->state >= ENET_PEER_STATE_CONNECTION_PENDING) {
-           host->recalculateBandwidthLimits = 1;
-        }
-
-        if (peer->state != ENET_PEER_STATE_CONNECTING && peer->state < ENET_PEER_STATE_CONNECTION_SUCCEEDED) {
-            enet_peer_reset (peer);
-        }
-        else if (event != NULL) {
-            event->type = ENET_EVENT_TYPE_DISCONNECT_TIMEOUT;
-            event->peer = peer;
-            event->data = 0;
-
-            enet_peer_reset(peer);
-        } else {
-            peer->eventData = 0;
-            enet_protocol_dispatch_state(host, peer, ENET_PEER_STATE_ZOMBIE);
-        }
-    }
-
-    static void enet_protocol_remove_sent_unreliable_commands(ENetPeer *peer) {
-        ENetOutgoingCommand *outgoingCommand;
-
-        while (!enet_list_empty(&peer->sentUnreliableCommands)) {
-            outgoingCommand = (ENetOutgoingCommand *)enet_list_front(&peer->sentUnreliableCommands);
-            enet_list_remove(&outgoingCommand->outgoingCommandList);
-
-            if (outgoingCommand->packet != NULL) {
-                --outgoingCommand->packet->referenceCount;
-
-                if (outgoingCommand->packet->referenceCount == 0) {
-                    outgoingCommand->packet->flags |= ENET_PACKET_FLAG_SENT;
-                    enet_packet_destroy(outgoingCommand->packet);
-                }
-            }
-
-            enet_free(outgoingCommand);
-        }
-    }
-
-    static ENetProtocolCommand enet_protocol_remove_sent_reliable_command(ENetPeer *peer, enet_uint16 reliableSequenceNumber, enet_uint8 channelID) {
-        ENetOutgoingCommand *outgoingCommand = NULL;
-        ENetListIterator currentCommand;
-        ENetProtocolCommand commandNumber;
-
-        int wasSent = 1;
-
-        for (currentCommand = enet_list_begin(&peer->sentReliableCommands);
-            currentCommand != enet_list_end(&peer->sentReliableCommands);
-            currentCommand = enet_list_next(currentCommand)
-        ) {
-            outgoingCommand = (ENetOutgoingCommand *)currentCommand;
-
-            if (outgoingCommand->reliableSequenceNumber == reliableSequenceNumber && outgoingCommand->command.header.channelID == channelID) {
-                break;
-            }
-        }
-
-        if (currentCommand == enet_list_end(&peer->sentReliableCommands)) {
-            for (currentCommand = enet_list_begin(&peer->outgoingReliableCommands);
-                currentCommand != enet_list_end(&peer->outgoingReliableCommands);
-                currentCommand = enet_list_next(currentCommand)
-            ) {
-                outgoingCommand = (ENetOutgoingCommand *)currentCommand;
-
-                if (outgoingCommand->sendAttempts < 1) {
-                    return ENET_PROTOCOL_COMMAND_NONE;
-                }
-
-                if (outgoingCommand->reliableSequenceNumber == reliableSequenceNumber && outgoingCommand->command.header.channelID == channelID) {
-                    break;
-                }
-            }
-
-            if (currentCommand == enet_list_end(&peer->outgoingReliableCommands)) {
-                return ENET_PROTOCOL_COMMAND_NONE;
-            }
-
-            wasSent = 0;
-        }
-
-        if (outgoingCommand == NULL) {
-            return ENET_PROTOCOL_COMMAND_NONE;
-        }
-
-        if (channelID < peer->channelCount) {
-            ENetChannel *channel       = &peer->channels[channelID];
-            enet_uint16 reliableWindow = reliableSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE;
-            if (channel->reliableWindows[reliableWindow] > 0) {
-                --channel->reliableWindows[reliableWindow];
-
-                if (!channel->reliableWindows[reliableWindow]) {
-                    channel->usedReliableWindows &= ~(1 << reliableWindow);
-                }
-            }
-        }
-
-        commandNumber = (ENetProtocolCommand) (outgoingCommand->command.header.command & ENET_PROTOCOL_COMMAND_MASK);
-
-        enet_list_remove(&outgoingCommand->outgoingCommandList);
-
-        if (outgoingCommand->packet != NULL) {
-            if (wasSent) {
-                peer->reliableDataInTransit -= outgoingCommand->fragmentLength;
-            }
-
-            --outgoingCommand->packet->referenceCount;
-
-            if (outgoingCommand->packet->referenceCount == 0) {
-                outgoingCommand->packet->flags |= ENET_PACKET_FLAG_SENT;
-                enet_packet_destroy(outgoingCommand->packet);
-            }
-        }
-
-        enet_free(outgoingCommand);
-
-        if (enet_list_empty(&peer->sentReliableCommands)) {
-            return commandNumber;
-        }
-
-        outgoingCommand = (ENetOutgoingCommand *)enet_list_front(&peer->sentReliableCommands);
-        peer->nextTimeout = outgoingCommand->sentTime + outgoingCommand->roundTripTimeout;
-
-        return commandNumber;
-    }
-
-    static ENetPeer * enet_protocol_handle_connect(ENetHost *host, ENetProtocolHeader *header, ENetProtocol *command) {
-        enet_uint8 incomingSessionID, outgoingSessionID;
-        enet_uint32 mtu, windowSize;
-        ENetChannel *channel;
-
-        size_t channelCount, duplicatePeers = 0;
-
-        ENetPeer *currentPeer, *peer = NULL;
-        ENetProtocol verifyCommand;
-
-        channelCount = ENET_NET_TO_HOST_32(command->connect.channelCount);
-
-        if (channelCount < ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT || channelCount > ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT) {
-            return NULL;
-        }
-
-        for (currentPeer = host->peers; currentPeer < &host->peers[host->peerCount]; ++currentPeer) {
-            if (currentPeer->state == ENET_PEER_STATE_DISCONNECTED) {
-                if (peer == NULL) {
-                    peer = currentPeer;
-                }
-            } else if (currentPeer->state != ENET_PEER_STATE_CONNECTING && in6_equal(currentPeer->address.host, host->receivedAddress.host)) {
-                if (currentPeer->address.port == host->receivedAddress.port && currentPeer->connectID == command->connect.connectID) {
-                    return NULL;
-                }
-
-                ++duplicatePeers;
-            }
-        }
-
-        if (peer == NULL || duplicatePeers >= host->duplicatePeers) {
-            return NULL;
-        }
-
-        if (channelCount > host->channelLimit) {
-            channelCount = host->channelLimit;
-        }
-
-        peer->channels = (ENetChannel *)enet_malloc(channelCount * sizeof(ENetChannel));
-
-        if (peer->channels == NULL) {
-            return NULL;
-        }
-
-        peer->channelCount               = channelCount;
-        peer->state                      = ENET_PEER_STATE_ACKNOWLEDGING_CONNECT;
-        peer->connectID                  = command->connect.connectID;
-        peer->address                    = host->receivedAddress;
-        peer->outgoingPeerID             = ENET_NET_TO_HOST_16(command->connect.outgoingPeerID);
-        peer->incomingBandwidth          = ENET_NET_TO_HOST_32(command->connect.incomingBandwidth);
-        peer->outgoingBandwidth          = ENET_NET_TO_HOST_32(command->connect.outgoingBandwidth);
-        peer->packetThrottleInterval     = ENET_NET_TO_HOST_32(command->connect.packetThrottleInterval);
-        peer->packetThrottleAcceleration = ENET_NET_TO_HOST_32(command->connect.packetThrottleAcceleration);
-        peer->packetThrottleDeceleration = ENET_NET_TO_HOST_32(command->connect.packetThrottleDeceleration);
-        peer->eventData                  = ENET_NET_TO_HOST_32(command->connect.data);
-
-        incomingSessionID = command->connect.incomingSessionID == 0xFF ? peer->outgoingSessionID : command->connect.incomingSessionID;
-        incomingSessionID = (incomingSessionID + 1) & (ENET_PROTOCOL_HEADER_SESSION_MASK >> ENET_PROTOCOL_HEADER_SESSION_SHIFT);
-
-        if (incomingSessionID == peer->outgoingSessionID) {
-            incomingSessionID = (incomingSessionID + 1)
-              & (ENET_PROTOCOL_HEADER_SESSION_MASK >> ENET_PROTOCOL_HEADER_SESSION_SHIFT);
-        }
-
-        peer->outgoingSessionID = incomingSessionID;
-
-        outgoingSessionID = command->connect.outgoingSessionID == 0xFF ? peer->incomingSessionID : command->connect.outgoingSessionID;
-        outgoingSessionID = (outgoingSessionID + 1) & (ENET_PROTOCOL_HEADER_SESSION_MASK >> ENET_PROTOCOL_HEADER_SESSION_SHIFT);
-
-        if (outgoingSessionID == peer->incomingSessionID) {
-            outgoingSessionID = (outgoingSessionID + 1)
-              & (ENET_PROTOCOL_HEADER_SESSION_MASK >> ENET_PROTOCOL_HEADER_SESSION_SHIFT);
-        }
-
-        peer->incomingSessionID = outgoingSessionID;
-
-        for (channel = peer->channels; channel < &peer->channels[channelCount]; ++channel) {
-            channel->outgoingReliableSequenceNumber   = 0;
-            channel->outgoingUnreliableSequenceNumber = 0;
-            channel->incomingReliableSequenceNumber   = 0;
-            channel->incomingUnreliableSequenceNumber = 0;
-
-            enet_list_clear(&channel->incomingReliableCommands);
-            enet_list_clear(&channel->incomingUnreliableCommands);
-
-            channel->usedReliableWindows = 0;
-            memset(channel->reliableWindows, 0, sizeof(channel->reliableWindows));
-        }
-
-        mtu = ENET_NET_TO_HOST_32(command->connect.mtu);
-
-        if (mtu < ENET_PROTOCOL_MINIMUM_MTU) {
-            mtu = ENET_PROTOCOL_MINIMUM_MTU;
-        } else if (mtu > ENET_PROTOCOL_MAXIMUM_MTU) {
-            mtu = ENET_PROTOCOL_MAXIMUM_MTU;
-        }
-
-        peer->mtu = mtu;
-
-        if (host->outgoingBandwidth == 0 && peer->incomingBandwidth == 0) {
-            peer->windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
-        } else if (host->outgoingBandwidth == 0 || peer->incomingBandwidth == 0) {
-            peer->windowSize = (ENET_MAX(host->outgoingBandwidth, peer->incomingBandwidth) / ENET_PEER_WINDOW_SIZE_SCALE) * ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
-        } else {
-            peer->windowSize = (ENET_MIN(host->outgoingBandwidth, peer->incomingBandwidth) / ENET_PEER_WINDOW_SIZE_SCALE) * ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
-        }
-
-        if (peer->windowSize < ENET_PROTOCOL_MINIMUM_WINDOW_SIZE) {
-            peer->windowSize = ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
-        } else if (peer->windowSize > ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE) {
-            peer->windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
-        }
-
-        if (host->incomingBandwidth == 0) {
-            windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
-        } else {
-            windowSize = (host->incomingBandwidth / ENET_PEER_WINDOW_SIZE_SCALE) * ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
-        }
-
-        if (windowSize > ENET_NET_TO_HOST_32(command->connect.windowSize)) {
-            windowSize = ENET_NET_TO_HOST_32(command->connect.windowSize);
-        }
-
-        if (windowSize < ENET_PROTOCOL_MINIMUM_WINDOW_SIZE) {
-            windowSize = ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
-        } else if (windowSize > ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE) {
-            windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
-        }
-
-        verifyCommand.header.command                            = ENET_PROTOCOL_COMMAND_VERIFY_CONNECT | ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE;
-        verifyCommand.header.channelID                          = 0xFF;
-        verifyCommand.verifyConnect.outgoingPeerID              = ENET_HOST_TO_NET_16(peer->incomingPeerID);
-        verifyCommand.verifyConnect.incomingSessionID           = incomingSessionID;
-        verifyCommand.verifyConnect.outgoingSessionID           = outgoingSessionID;
-        verifyCommand.verifyConnect.mtu                         = ENET_HOST_TO_NET_32(peer->mtu);
-        verifyCommand.verifyConnect.windowSize                  = ENET_HOST_TO_NET_32(windowSize);
-        verifyCommand.verifyConnect.channelCount                = ENET_HOST_TO_NET_32(channelCount);
-        verifyCommand.verifyConnect.incomingBandwidth           = ENET_HOST_TO_NET_32(host->incomingBandwidth);
-        verifyCommand.verifyConnect.outgoingBandwidth           = ENET_HOST_TO_NET_32(host->outgoingBandwidth);
-        verifyCommand.verifyConnect.packetThrottleInterval      = ENET_HOST_TO_NET_32(peer->packetThrottleInterval);
-        verifyCommand.verifyConnect.packetThrottleAcceleration  = ENET_HOST_TO_NET_32(peer->packetThrottleAcceleration);
-        verifyCommand.verifyConnect.packetThrottleDeceleration  = ENET_HOST_TO_NET_32(peer->packetThrottleDeceleration);
-        verifyCommand.verifyConnect.connectID                   = peer->connectID;
-
-        enet_peer_queue_outgoing_command(peer, &verifyCommand, NULL, 0, 0);
-
-        return peer;
-    }
-
-    static int enet_protocol_handle_send_reliable(ENetHost *host, ENetPeer *peer, const ENetProtocol *command, enet_uint8 **currentData) {
-        size_t dataLength;
-
-        if (command->header.channelID >= peer->channelCount || (peer->state != ENET_PEER_STATE_CONNECTED && peer->state != ENET_PEER_STATE_DISCONNECT_LATER)) {
-            return -1;
-        }
-
-        dataLength    = ENET_NET_TO_HOST_16(command->sendReliable.dataLength);
-        *currentData += dataLength;
-
-        if (dataLength > host->maximumPacketSize || *currentData < host->receivedData || *currentData > &host->receivedData[host->receivedDataLength]) {
-            return -1;
-        }
-
-        if (enet_peer_queue_incoming_command(peer, command, (const enet_uint8 *)command + sizeof(ENetProtocolSendReliable), dataLength, ENET_PACKET_FLAG_RELIABLE, 0) == NULL) {
-            return -1;
-        }
-
-        return 0;
-    }
-
-    static int enet_protocol_handle_send_unsequenced(ENetHost *host, ENetPeer *peer, const ENetProtocol *command, enet_uint8 **currentData) {
-        enet_uint32 unsequencedGroup, index;
-
-        size_t dataLength;
-
-        if (command->header.channelID >= peer->channelCount || (peer->state != ENET_PEER_STATE_CONNECTED && peer->state != ENET_PEER_STATE_DISCONNECT_LATER)) {
-            return -1;
-        }
-
-        dataLength    = ENET_NET_TO_HOST_16(command->sendUnsequenced.dataLength);
-        *currentData += dataLength;
-
-        if (dataLength > host->maximumPacketSize || *currentData < host->receivedData || *currentData > &host->receivedData[host->receivedDataLength]) {
-            return -1;
-        }
-
-        unsequencedGroup = ENET_NET_TO_HOST_16(command->sendUnsequenced.unsequencedGroup);
-        index = unsequencedGroup % ENET_PEER_UNSEQUENCED_WINDOW_SIZE;
-
-        if (unsequencedGroup < peer->incomingUnsequencedGroup) {
-            unsequencedGroup += 0x10000;
-        }
-
-        if (unsequencedGroup >= (enet_uint32) peer->incomingUnsequencedGroup + ENET_PEER_FREE_UNSEQUENCED_WINDOWS * ENET_PEER_UNSEQUENCED_WINDOW_SIZE) {
-            return 0;
-        }
-
-        unsequencedGroup &= 0xFFFF;
-
-        if (unsequencedGroup - index != peer->incomingUnsequencedGroup) {
-            peer->incomingUnsequencedGroup = unsequencedGroup - index;
-            memset(peer->unsequencedWindow, 0, sizeof(peer->unsequencedWindow));
-        } else if (peer->unsequencedWindow[index / 32] & (1 << (index % 32))) {
-            return 0;
-        }
-
-        if (enet_peer_queue_incoming_command(peer, command, (const enet_uint8 *)command + sizeof(ENetProtocolSendUnsequenced), dataLength, ENET_PACKET_FLAG_UNSEQUENCED,0) == NULL) {
-            return -1;
-        }
-
-        peer->unsequencedWindow[index / 32] |= 1 << (index % 32);
-
-        return 0;
-    }
-
-    static int enet_protocol_handle_send_unreliable(ENetHost *host, ENetPeer *peer, const ENetProtocol *command, enet_uint8 **currentData) {
-        size_t dataLength;
-
-        if (command->header.channelID >= peer->channelCount || (peer->state != ENET_PEER_STATE_CONNECTED && peer->state != ENET_PEER_STATE_DISCONNECT_LATER)) {
-            return -1;
-        }
-
-        dataLength    = ENET_NET_TO_HOST_16(command->sendUnreliable.dataLength);
-        *currentData += dataLength;
-
-        if (dataLength > host->maximumPacketSize || *currentData < host->receivedData || *currentData > &host->receivedData[host->receivedDataLength]) {
-            return -1;
-        }
-
-        if (enet_peer_queue_incoming_command(peer, command, (const enet_uint8 *)command + sizeof(ENetProtocolSendUnreliable), dataLength, 0, 0) == NULL) {
-            return -1;
-        }
-
-        return 0;
-    }
-
-    static int enet_protocol_handle_send_fragment(ENetHost *host, ENetPeer *peer, const ENetProtocol *command, enet_uint8 **currentData) {
-        enet_uint32 fragmentNumber, fragmentCount, fragmentOffset, fragmentLength, startSequenceNumber, totalLength;
-        ENetChannel *channel;
-        enet_uint16 startWindow, currentWindow;
-        ENetListIterator currentCommand;
-        ENetIncomingCommand *startCommand = NULL;
-
-        if (command->header.channelID >= peer->channelCount || (peer->state != ENET_PEER_STATE_CONNECTED && peer->state != ENET_PEER_STATE_DISCONNECT_LATER)) {
-            return -1;
-        }
-
-        fragmentLength = ENET_NET_TO_HOST_16(command->sendFragment.dataLength);
-        *currentData  += fragmentLength;
-
-        if (fragmentLength > host->maximumPacketSize || *currentData < host->receivedData || *currentData > &host->receivedData[host->receivedDataLength]) {
-            return -1;
-        }
-
-        channel = &peer->channels[command->header.channelID];
-        startSequenceNumber = ENET_NET_TO_HOST_16(command->sendFragment.startSequenceNumber);
-        startWindow         = startSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE;
-        currentWindow       = channel->incomingReliableSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE;
-
-        if (startSequenceNumber < channel->incomingReliableSequenceNumber) {
-            startWindow += ENET_PEER_RELIABLE_WINDOWS;
-        }
-
-        if (startWindow < currentWindow || startWindow >= currentWindow + ENET_PEER_FREE_RELIABLE_WINDOWS - 1) {
-            return 0;
-        }
-
-        fragmentNumber = ENET_NET_TO_HOST_32(command->sendFragment.fragmentNumber);
-        fragmentCount  = ENET_NET_TO_HOST_32(command->sendFragment.fragmentCount);
-        fragmentOffset = ENET_NET_TO_HOST_32(command->sendFragment.fragmentOffset);
-        totalLength    = ENET_NET_TO_HOST_32(command->sendFragment.totalLength);
-
-        if (fragmentCount > ENET_PROTOCOL_MAXIMUM_FRAGMENT_COUNT ||
-            fragmentNumber >= fragmentCount ||
-            totalLength > host->maximumPacketSize ||
-            fragmentOffset >= totalLength ||
-            fragmentLength > totalLength - fragmentOffset
-        ) {
-            return -1;
-        }
-
-        for (currentCommand = enet_list_previous(enet_list_end(&channel->incomingReliableCommands));
-            currentCommand != enet_list_end(&channel->incomingReliableCommands);
-            currentCommand = enet_list_previous(currentCommand)
-        ) {
-            ENetIncomingCommand *incomingCommand = (ENetIncomingCommand *)currentCommand;
-
-            if (startSequenceNumber >= channel->incomingReliableSequenceNumber) {
-                if (incomingCommand->reliableSequenceNumber < channel->incomingReliableSequenceNumber) {
-                    continue;
-                }
-            } else if (incomingCommand->reliableSequenceNumber >= channel->incomingReliableSequenceNumber) {
-                break;
-            }
-
-            if (incomingCommand->reliableSequenceNumber <= startSequenceNumber) {
-                if (incomingCommand->reliableSequenceNumber < startSequenceNumber) {
-                    break;
-                }
-
-                if ((incomingCommand->command.header.command & ENET_PROTOCOL_COMMAND_MASK) !=
-                    ENET_PROTOCOL_COMMAND_SEND_FRAGMENT ||
-                    totalLength != incomingCommand->packet->dataLength ||
-                    fragmentCount != incomingCommand->fragmentCount
-                ) {
-                    return -1;
-                }
-
-                startCommand = incomingCommand;
-
-                break;
-            }
-        }
-
-        if (startCommand == NULL) {
-            ENetProtocol hostCommand = *command;
-            hostCommand.header.reliableSequenceNumber = startSequenceNumber;
-            startCommand = enet_peer_queue_incoming_command(peer, &hostCommand, NULL, totalLength, ENET_PACKET_FLAG_RELIABLE, fragmentCount);
-
-            if (startCommand == NULL) {
-                return -1;
-            }
-        }
-
-        if ((startCommand->fragments[fragmentNumber / 32] & (1 << (fragmentNumber % 32))) == 0) {
-            --startCommand->fragmentsRemaining;
-            startCommand->fragments[fragmentNumber / 32] |= (1 << (fragmentNumber % 32));
-
-            if (fragmentOffset + fragmentLength > startCommand->packet->dataLength) {
-                fragmentLength = startCommand->packet->dataLength - fragmentOffset;
-            }
-
-            memcpy(startCommand->packet->data + fragmentOffset, (enet_uint8 *)command + sizeof(ENetProtocolSendFragment), fragmentLength);
-
-            if (startCommand->fragmentsRemaining <= 0) {
-                enet_peer_dispatch_incoming_reliable_commands(peer, channel);
-            }
-        }
-
-        return 0;
-    }
-
-    static int enet_protocol_handle_send_unreliable_fragment(ENetHost *host, ENetPeer *peer, const ENetProtocol *command, enet_uint8 **currentData) {
-        enet_uint32 fragmentNumber, fragmentCount, fragmentOffset, fragmentLength, reliableSequenceNumber, startSequenceNumber, totalLength;
-        enet_uint16 reliableWindow, currentWindow;
-        ENetChannel *channel;
-        ENetListIterator currentCommand;
-        ENetIncomingCommand *startCommand = NULL;
-
-        if (command->header.channelID >= peer->channelCount || (peer->state != ENET_PEER_STATE_CONNECTED && peer->state != ENET_PEER_STATE_DISCONNECT_LATER)) {
-            return -1;
-        }
-
-        fragmentLength = ENET_NET_TO_HOST_16(command->sendFragment.dataLength);
-        *currentData  += fragmentLength;
-
-        if (fragmentLength > host->maximumPacketSize || *currentData < host->receivedData || *currentData > &host->receivedData[host->receivedDataLength]) {
-            return -1;
-        }
-
-        channel = &peer->channels[command->header.channelID];
-        reliableSequenceNumber = command->header.reliableSequenceNumber;
-        startSequenceNumber    = ENET_NET_TO_HOST_16(command->sendFragment.startSequenceNumber);
-
-        reliableWindow = reliableSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE;
-        currentWindow  = channel->incomingReliableSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE;
-
-        if (reliableSequenceNumber < channel->incomingReliableSequenceNumber) {
-            reliableWindow += ENET_PEER_RELIABLE_WINDOWS;
-        }
-
-        if (reliableWindow < currentWindow || reliableWindow >= currentWindow + ENET_PEER_FREE_RELIABLE_WINDOWS - 1) {
-            return 0;
-        }
-
-        if (reliableSequenceNumber == channel->incomingReliableSequenceNumber && startSequenceNumber <= channel->incomingUnreliableSequenceNumber) {
-            return 0;
-        }
-
-        fragmentNumber = ENET_NET_TO_HOST_32(command->sendFragment.fragmentNumber);
-        fragmentCount  = ENET_NET_TO_HOST_32(command->sendFragment.fragmentCount);
-        fragmentOffset = ENET_NET_TO_HOST_32(command->sendFragment.fragmentOffset);
-        totalLength    = ENET_NET_TO_HOST_32(command->sendFragment.totalLength);
-
-        if (fragmentCount > ENET_PROTOCOL_MAXIMUM_FRAGMENT_COUNT ||
-            fragmentNumber >= fragmentCount ||
-            totalLength > host->maximumPacketSize ||
-            fragmentOffset >= totalLength ||
-            fragmentLength > totalLength - fragmentOffset
-        ) {
-            return -1;
-        }
-
-        for (currentCommand = enet_list_previous(enet_list_end(&channel->incomingUnreliableCommands));
-            currentCommand != enet_list_end(&channel->incomingUnreliableCommands);
-            currentCommand = enet_list_previous(currentCommand)
-        ) {
-            ENetIncomingCommand *incomingCommand = (ENetIncomingCommand *)currentCommand;
-
-            if (reliableSequenceNumber >= channel->incomingReliableSequenceNumber) {
-                if (incomingCommand->reliableSequenceNumber < channel->incomingReliableSequenceNumber) {
-                    continue;
-                }
-            } else if (incomingCommand->reliableSequenceNumber >= channel->incomingReliableSequenceNumber) {
-                break;
-            }
-
-            if (incomingCommand->reliableSequenceNumber < reliableSequenceNumber) {
-                break;
-            }
-
-            if (incomingCommand->reliableSequenceNumber > reliableSequenceNumber) {
-                continue;
-            }
-
-            if (incomingCommand->unreliableSequenceNumber <= startSequenceNumber) {
-                if (incomingCommand->unreliableSequenceNumber < startSequenceNumber) {
-                    break;
-                }
-
-                if ((incomingCommand->command.header.command & ENET_PROTOCOL_COMMAND_MASK) !=
-                    ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE_FRAGMENT ||
-                    totalLength != incomingCommand->packet->dataLength ||
-                    fragmentCount != incomingCommand->fragmentCount
-                ) {
-                    return -1;
-                }
-
-                startCommand = incomingCommand;
-
-                break;
-            }
-        }
-
-        if (startCommand == NULL) {
-            startCommand = enet_peer_queue_incoming_command(peer, command, NULL, totalLength,
-                ENET_PACKET_FLAG_UNRELIABLE_FRAGMENT, fragmentCount);
-            if (startCommand == NULL) {
-                return -1;
-            }
-        }
-
-        if ((startCommand->fragments[fragmentNumber / 32] & (1 << (fragmentNumber % 32))) == 0) {
-            --startCommand->fragmentsRemaining;
-            startCommand->fragments[fragmentNumber / 32] |= (1 << (fragmentNumber % 32));
-
-            if (fragmentOffset + fragmentLength > startCommand->packet->dataLength) {
-                fragmentLength = startCommand->packet->dataLength - fragmentOffset;
-            }
-
-            memcpy(startCommand->packet->data + fragmentOffset, (enet_uint8 *)command + sizeof(ENetProtocolSendFragment), fragmentLength);
-
-            if (startCommand->fragmentsRemaining <= 0) {
-                enet_peer_dispatch_incoming_unreliable_commands(peer, channel);
-            }
-        }
-
-        return 0;
-    }
-
-    static int enet_protocol_handle_ping(ENetHost *host, ENetPeer *peer, const ENetProtocol *command) {
-        if (peer->state != ENET_PEER_STATE_CONNECTED && peer->state != ENET_PEER_STATE_DISCONNECT_LATER) {
-            return -1;
-        }
-
-        return 0;
-    }
-
-    static int enet_protocol_handle_bandwidth_limit(ENetHost *host, ENetPeer *peer, const ENetProtocol *command) {
-        if (peer->state != ENET_PEER_STATE_CONNECTED && peer->state != ENET_PEER_STATE_DISCONNECT_LATER) {
-            return -1;
-        }
-
-        if (peer->incomingBandwidth != 0) {
-            --host->bandwidthLimitedPeers;
-        }
-
-        peer->incomingBandwidth = ENET_NET_TO_HOST_32(command->bandwidthLimit.incomingBandwidth);
-        peer->outgoingBandwidth = ENET_NET_TO_HOST_32(command->bandwidthLimit.outgoingBandwidth);
-
-        if (peer->incomingBandwidth != 0) {
-            ++host->bandwidthLimitedPeers;
-        }
-
-        if (peer->incomingBandwidth == 0 && host->outgoingBandwidth == 0) {
-            peer->windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
-        } else if (peer->incomingBandwidth == 0 || host->outgoingBandwidth == 0) {
-            peer->windowSize = (ENET_MAX(peer->incomingBandwidth, host->outgoingBandwidth)
-              / ENET_PEER_WINDOW_SIZE_SCALE) * ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
-        } else {
-            peer->windowSize = (ENET_MIN(peer->incomingBandwidth, host->outgoingBandwidth)
-              / ENET_PEER_WINDOW_SIZE_SCALE) * ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
-        }
-
-        if (peer->windowSize < ENET_PROTOCOL_MINIMUM_WINDOW_SIZE) {
-            peer->windowSize = ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
-        } else if (peer->windowSize > ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE) {
-            peer->windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
-        }
-
-        return 0;
-    }
-
-    static int enet_protocol_handle_throttle_configure(ENetHost *host, ENetPeer *peer, const ENetProtocol *command) {
-        if (peer->state != ENET_PEER_STATE_CONNECTED && peer->state != ENET_PEER_STATE_DISCONNECT_LATER) {
-            return -1;
-        }
-
-        peer->packetThrottleInterval     = ENET_NET_TO_HOST_32(command->throttleConfigure.packetThrottleInterval);
-        peer->packetThrottleAcceleration = ENET_NET_TO_HOST_32(command->throttleConfigure.packetThrottleAcceleration);
-        peer->packetThrottleDeceleration = ENET_NET_TO_HOST_32(command->throttleConfigure.packetThrottleDeceleration);
-
-        return 0;
-    }
-
-    static int enet_protocol_handle_disconnect(ENetHost *host, ENetPeer *peer, const ENetProtocol *command) {
-        if (peer->state == ENET_PEER_STATE_DISCONNECTED || peer->state == ENET_PEER_STATE_ZOMBIE ||
-            peer->state == ENET_PEER_STATE_ACKNOWLEDGING_DISCONNECT
-        ) {
-            return 0;
-        }
-
-        enet_peer_reset_queues(peer);
-
-        if (peer->state == ENET_PEER_STATE_CONNECTION_SUCCEEDED || peer->state == ENET_PEER_STATE_DISCONNECTING || peer->state == ENET_PEER_STATE_CONNECTING) {
-            enet_protocol_dispatch_state(host, peer, ENET_PEER_STATE_ZOMBIE);
-        } else if (peer->state != ENET_PEER_STATE_CONNECTED && peer->state != ENET_PEER_STATE_DISCONNECT_LATER) {
-            if (peer->state == ENET_PEER_STATE_CONNECTION_PENDING) { host->recalculateBandwidthLimits = 1; }
-            enet_peer_reset(peer);
-        } else if (command->header.command & ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE) {
-            enet_protocol_change_state(host, peer, ENET_PEER_STATE_ACKNOWLEDGING_DISCONNECT);
-        } else {
-            enet_protocol_dispatch_state(host, peer, ENET_PEER_STATE_ZOMBIE);
-        }
-
-        if (peer->state != ENET_PEER_STATE_DISCONNECTED) {
-            peer->eventData = ENET_NET_TO_HOST_32(command->disconnect.data);
-        }
-
-        return 0;
-    }
-
-    static int enet_protocol_handle_acknowledge(ENetHost *host, ENetEvent *event, ENetPeer *peer, const ENetProtocol *command) {
-        enet_uint32 roundTripTime, receivedSentTime, receivedReliableSequenceNumber;
-        ENetProtocolCommand commandNumber;
-
-        if (peer->state == ENET_PEER_STATE_DISCONNECTED || peer->state == ENET_PEER_STATE_ZOMBIE) {
-            return 0;
-        }
-
-        receivedSentTime  = ENET_NET_TO_HOST_16(command->acknowledge.receivedSentTime);
-        receivedSentTime |= host->serviceTime & 0xFFFF0000;
-
-        if ((receivedSentTime & 0x8000) > (host->serviceTime & 0x8000)) {
-            receivedSentTime -= 0x10000;
-        }
-
-        if (ENET_TIME_LESS(host->serviceTime, receivedSentTime)) {
-            return 0;
-        }
-
-        peer->lastReceiveTime = host->serviceTime;
-        peer->earliestTimeout = 0;
-        roundTripTime = ENET_TIME_DIFFERENCE(host->serviceTime, receivedSentTime);
-
-        enet_peer_throttle(peer, roundTripTime);
-        peer->roundTripTimeVariance -= peer->roundTripTimeVariance / 4;
-
-        if (roundTripTime >= peer->roundTripTime) {
-            peer->roundTripTime         += (roundTripTime - peer->roundTripTime) / 8;
-            peer->roundTripTimeVariance += (roundTripTime - peer->roundTripTime) / 4;
-        } else {
-            peer->roundTripTime         -= (peer->roundTripTime - roundTripTime) / 8;
-            peer->roundTripTimeVariance += (peer->roundTripTime - roundTripTime) / 4;
-        }
-
-        if (peer->roundTripTime < peer->lowestRoundTripTime) {
-            peer->lowestRoundTripTime = peer->roundTripTime;
-        }
-
-        if (peer->roundTripTimeVariance > peer->highestRoundTripTimeVariance) {
-            peer->highestRoundTripTimeVariance = peer->roundTripTimeVariance;
-        }
-
-        if (peer->packetThrottleEpoch == 0 ||
-            ENET_TIME_DIFFERENCE(host->serviceTime, peer->packetThrottleEpoch) >= peer->packetThrottleInterval
-        ) {
-            peer->lastRoundTripTime            = peer->lowestRoundTripTime;
-            peer->lastRoundTripTimeVariance    = peer->highestRoundTripTimeVariance;
-            peer->lowestRoundTripTime          = peer->roundTripTime;
-            peer->highestRoundTripTimeVariance = peer->roundTripTimeVariance;
-            peer->packetThrottleEpoch          = host->serviceTime;
-        }
-
-        receivedReliableSequenceNumber = ENET_NET_TO_HOST_16(command->acknowledge.receivedReliableSequenceNumber);
-        commandNumber = enet_protocol_remove_sent_reliable_command(peer, receivedReliableSequenceNumber, command->header.channelID);
-
-        switch (peer->state) {
-            case ENET_PEER_STATE_ACKNOWLEDGING_CONNECT:
-                if (commandNumber != ENET_PROTOCOL_COMMAND_VERIFY_CONNECT) {
-                    return -1;
-                }
-
-                enet_protocol_notify_connect(host, peer, event);
-                break;
-
-            case ENET_PEER_STATE_DISCONNECTING:
-                if (commandNumber != ENET_PROTOCOL_COMMAND_DISCONNECT) {
-                    return -1;
-                }
-
-                enet_protocol_notify_disconnect(host, peer, event);
-                break;
-
-            case ENET_PEER_STATE_DISCONNECT_LATER:
-                if (enet_list_empty(&peer->outgoingReliableCommands) &&
-                  enet_list_empty(&peer->outgoingUnreliableCommands) &&
-                  enet_list_empty(&peer->sentReliableCommands))
-                {
-                    enet_peer_disconnect(peer, peer->eventData);
-                }
-                break;
-
-            default:
-                break;
-        }
-
-        return 0;
-    }
-
-    static int enet_protocol_handle_verify_connect(ENetHost *host, ENetEvent *event, ENetPeer *peer, const ENetProtocol *command) {
-        enet_uint32 mtu, windowSize;
-        size_t channelCount;
-
-        if (peer->state != ENET_PEER_STATE_CONNECTING) {
-            return 0;
-        }
-
-        channelCount = ENET_NET_TO_HOST_32(command->verifyConnect.channelCount);
-
-        if (channelCount < ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT || channelCount > ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT ||
-            ENET_NET_TO_HOST_32(command->verifyConnect.packetThrottleInterval) != peer->packetThrottleInterval ||
-            ENET_NET_TO_HOST_32(command->verifyConnect.packetThrottleAcceleration) != peer->packetThrottleAcceleration ||
-            ENET_NET_TO_HOST_32(command->verifyConnect.packetThrottleDeceleration) != peer->packetThrottleDeceleration ||
-            command->verifyConnect.connectID != peer->connectID
-        ) {
-            peer->eventData = 0;
-
-            enet_protocol_dispatch_state(host, peer, ENET_PEER_STATE_ZOMBIE);
-
-            return -1;
-        }
-
-        enet_protocol_remove_sent_reliable_command(peer, 1, 0xFF);
-
-        if (channelCount < peer->channelCount) {
-            peer->channelCount = channelCount;
-        }
-
-        peer->outgoingPeerID    = ENET_NET_TO_HOST_16(command->verifyConnect.outgoingPeerID);
-        peer->incomingSessionID = command->verifyConnect.incomingSessionID;
-        peer->outgoingSessionID = command->verifyConnect.outgoingSessionID;
-
-        mtu = ENET_NET_TO_HOST_32(command->verifyConnect.mtu);
-
-        if (mtu < ENET_PROTOCOL_MINIMUM_MTU) {
-            mtu = ENET_PROTOCOL_MINIMUM_MTU;
-        } else if (mtu > ENET_PROTOCOL_MAXIMUM_MTU) {
-            mtu = ENET_PROTOCOL_MAXIMUM_MTU;
-        }
-
-        if (mtu < peer->mtu) {
-            peer->mtu = mtu;
-        }
-
-        windowSize = ENET_NET_TO_HOST_32(command->verifyConnect.windowSize);
-
-        if (windowSize < ENET_PROTOCOL_MINIMUM_WINDOW_SIZE) {
-            windowSize = ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
-        }
-
-        if (windowSize > ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE) {
-            windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
-        }
-
-        if (windowSize < peer->windowSize) {
-            peer->windowSize = windowSize;
-        }
-
-        peer->incomingBandwidth = ENET_NET_TO_HOST_32(command->verifyConnect.incomingBandwidth);
-        peer->outgoingBandwidth = ENET_NET_TO_HOST_32(command->verifyConnect.outgoingBandwidth);
-
-        enet_protocol_notify_connect(host, peer, event);
-
-        return 0;
-    }
-
-    static int enet_protocol_handle_incoming_commands(ENetHost *host, ENetEvent *event) {
-        ENetProtocolHeader *header;
-        ENetProtocol *command;
-        ENetPeer *peer;
-        enet_uint8 *currentData;
-        size_t headerSize;
-        enet_uint16 peerID, flags;
-        enet_uint8 sessionID;
-
-        if (host->receivedDataLength < (size_t) &((ENetProtocolHeader *)0)->sentTime) {
-            return 0;
-        }
-
-        header = (ENetProtocolHeader *)host->receivedData;
-
-        peerID    = ENET_NET_TO_HOST_16(header->peerID);
-        sessionID = (peerID & ENET_PROTOCOL_HEADER_SESSION_MASK) >> ENET_PROTOCOL_HEADER_SESSION_SHIFT;
-        flags     = peerID & ENET_PROTOCOL_HEADER_FLAG_MASK;
-        peerID   &= ~(ENET_PROTOCOL_HEADER_FLAG_MASK | ENET_PROTOCOL_HEADER_SESSION_MASK);
-
-        headerSize = (flags & ENET_PROTOCOL_HEADER_FLAG_SENT_TIME ? sizeof(ENetProtocolHeader) : (size_t) &((ENetProtocolHeader *)0)->sentTime);
-
-        if (host->checksum != NULL) {
-            headerSize += sizeof(enet_uint32);
-        }
-
-        if (peerID == ENET_PROTOCOL_MAXIMUM_PEER_ID) {
-            peer = NULL;
-        } else if (peerID >= host->peerCount) {
-            return 0;
-        } else {
-            peer = &host->peers[peerID];
-
-            if (peer->state == ENET_PEER_STATE_DISCONNECTED ||
-                peer->state == ENET_PEER_STATE_ZOMBIE ||
-                ((!in6_equal(host->receivedAddress.host , peer->address.host) ||
-                host->receivedAddress.port != peer->address.port) &&
-                1 /* No broadcast in IPv6 - !in6_equal(peer->address.host , ENET_HOST_BROADCAST) */) ||
-                (peer->outgoingPeerID < ENET_PROTOCOL_MAXIMUM_PEER_ID &&
-                sessionID != peer->incomingSessionID)
-            ) {
-                return 0;
-            }
-        }
-
-        if (host->checksum != NULL) {
-            enet_uint32 *checksum = (enet_uint32 *)&host->receivedData[headerSize - sizeof(enet_uint32)];
-            enet_uint32 desiredChecksum = *checksum;
-            ENetBuffer buffer;
-
-            *checksum = peer != NULL ? peer->connectID : 0;
-
-            buffer.data       = host->receivedData;
-            buffer.dataLength = host->receivedDataLength;
-
-            if (host->checksum(&buffer, 1) != desiredChecksum) {
-                return 0;
-            }
-        }
-
-        if (peer != NULL) {
-            peer->address.host       = host->receivedAddress.host;
-            peer->address.port       = host->receivedAddress.port;
-            peer->incomingDataTotal += host->receivedDataLength;
-            peer->totalDataReceived += host->receivedDataLength;
-        }
-
-        currentData = host->receivedData + headerSize;
-
-        while (currentData < &host->receivedData[host->receivedDataLength]) {
-            enet_uint8 commandNumber;
-            size_t commandSize;
-
-            command = (ENetProtocol *)currentData;
-
-            if (currentData + sizeof(ENetProtocolCommandHeader) > &host->receivedData[host->receivedDataLength]) {
-                break;
-            }
-
-            commandNumber = command->header.command & ENET_PROTOCOL_COMMAND_MASK;
-
-            if (commandNumber >= ENET_PROTOCOL_COMMAND_COUNT) {
-                break;
-            }
-
-            commandSize = commandSizes[commandNumber];
-
-            if (commandSize == 0 || currentData + commandSize > &host->receivedData[host->receivedDataLength]) {
-                break;
-            }
-
-            currentData += commandSize;
-
-            if (peer == NULL && (commandNumber != ENET_PROTOCOL_COMMAND_CONNECT || currentData < &host->receivedData[host->receivedDataLength])) {
-                break;
-            }
-
-            command->header.reliableSequenceNumber = ENET_NET_TO_HOST_16(command->header.reliableSequenceNumber);
-
-            switch (commandNumber) {
-                case ENET_PROTOCOL_COMMAND_ACKNOWLEDGE:
-                    if (enet_protocol_handle_acknowledge(host, event, peer, command)) {
-                        goto commandError;
-                    }
-                    break;
-
-                case ENET_PROTOCOL_COMMAND_CONNECT:
-                    if (peer != NULL) {
-                        goto commandError;
-                    }
-                    peer = enet_protocol_handle_connect(host, header, command);
-                    if (peer == NULL) {
-                        goto commandError;
-                    }
-                    break;
-
-                case ENET_PROTOCOL_COMMAND_VERIFY_CONNECT:
-                    if (enet_protocol_handle_verify_connect(host, event, peer, command)) {
-                        goto commandError;
-                    }
-                    break;
-
-                case ENET_PROTOCOL_COMMAND_DISCONNECT:
-                    if (enet_protocol_handle_disconnect(host, peer, command)) {
-                        goto commandError;
-                    }
-                    break;
-
-                case ENET_PROTOCOL_COMMAND_PING:
-                    if (enet_protocol_handle_ping(host, peer, command)) {
-                        goto commandError;
-                    }
-                    break;
-
-                case ENET_PROTOCOL_COMMAND_SEND_RELIABLE:
-                    if (enet_protocol_handle_send_reliable(host, peer, command, &currentData)) {
-                        goto commandError;
-                    }
-                    break;
-
-                case ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE:
-                    if (enet_protocol_handle_send_unreliable(host, peer, command, &currentData)) {
-                        goto commandError;
-                    }
-                    break;
-
-                case ENET_PROTOCOL_COMMAND_SEND_UNSEQUENCED:
-                    if (enet_protocol_handle_send_unsequenced(host, peer, command, &currentData)) {
-                        goto commandError;
-                    }
-                    break;
-
-                case ENET_PROTOCOL_COMMAND_SEND_FRAGMENT:
-                    if (enet_protocol_handle_send_fragment(host, peer, command, &currentData)) {
-                        goto commandError;
-                    }
-                    break;
-
-                case ENET_PROTOCOL_COMMAND_BANDWIDTH_LIMIT:
-                    if (enet_protocol_handle_bandwidth_limit(host, peer, command)) {
-                        goto commandError;
-                    }
-                    break;
-
-                case ENET_PROTOCOL_COMMAND_THROTTLE_CONFIGURE:
-                    if (enet_protocol_handle_throttle_configure(host, peer, command)) {
-                        goto commandError;
-                    }
-                    break;
-
-                case ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE_FRAGMENT:
-                    if (enet_protocol_handle_send_unreliable_fragment(host, peer, command, &currentData)) {
-                        goto commandError;
-                    }
-                    break;
-
-                default:
-                    goto commandError;
-            }
-
-            if (peer != NULL && (command->header.command & ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE) != 0) {
-                enet_uint16 sentTime;
-
-                if (!(flags & ENET_PROTOCOL_HEADER_FLAG_SENT_TIME)) {
-                    break;
-                }
-
-                sentTime = ENET_NET_TO_HOST_16(header->sentTime);
-
-                switch (peer->state) {
-                    case ENET_PEER_STATE_DISCONNECTING:
-                    case ENET_PEER_STATE_ACKNOWLEDGING_CONNECT:
-                    case ENET_PEER_STATE_DISCONNECTED:
-                    case ENET_PEER_STATE_ZOMBIE:
-                        break;
-
-                    case ENET_PEER_STATE_ACKNOWLEDGING_DISCONNECT:
-                        if ((command->header.command & ENET_PROTOCOL_COMMAND_MASK) == ENET_PROTOCOL_COMMAND_DISCONNECT) {
-                            enet_peer_queue_acknowledgement(peer, command, sentTime);
-                        }
-                        break;
-
-                    default:
-                        enet_peer_queue_acknowledgement(peer, command, sentTime);
-                        break;
-                }
-            }
-        }
-
-    commandError:
-        if (event != NULL && event->type != ENET_EVENT_TYPE_NONE) {
-            return 1;
-        }
-
-        return 0;
-    }
-
-    static int enet_protocol_receive_incoming_commands(ENetHost *host, ENetEvent *event) {
-        int packets;
-
-        for (packets = 0; packets < 256; ++packets) {
-            int receivedLength;
-            ENetBuffer buffer;
-
-            buffer.data       = host->packetData[0];
-            buffer.dataLength = host->mtu;
-
-            receivedLength    = enet_socket_receive(host->socket, &host->receivedAddress, &buffer, 1);
-
-            if (receivedLength == -2)
-                continue;
-
-            if (receivedLength < 0) {
-                return -1;
-            }
-
-            if (receivedLength == 0) {
-                return 0;
-            }
-
-            host->receivedData       = host->packetData[0];
-            host->receivedDataLength = receivedLength;
-
-            host->totalReceivedData += receivedLength;
-            host->totalReceivedPackets++;
-
-            if (host->intercept != NULL) {
-                switch (host->intercept(host, (void *)event)) {
-                    case 1:
-                        if (event != NULL && event->type != ENET_EVENT_TYPE_NONE) {
-                            return 1;
-                        }
-
-                        continue;
-
-                    case -1:
-                        return -1;
-
-                    default:
-                        break;
-                }
-            }
-
-            switch (enet_protocol_handle_incoming_commands(host, event)) {
-                case 1:
-                    return 1;
-
-                case -1:
-                    return -1;
-
-                default:
-                    break;
-            }
-        }
-
-        return -1;
-    }
-
-    static void enet_protocol_send_acknowledgements(ENetHost *host, ENetPeer *peer) {
-        ENetProtocol *command = &host->commands[host->commandCount];
-        ENetBuffer *buffer    = &host->buffers[host->bufferCount];
-        ENetAcknowledgement *acknowledgement;
-        ENetListIterator currentAcknowledgement;
-        enet_uint16 reliableSequenceNumber;
-
-        currentAcknowledgement = enet_list_begin(&peer->acknowledgements);
-
-        while (currentAcknowledgement != enet_list_end(&peer->acknowledgements)) {
-            if (command >= &host->commands[sizeof(host->commands) / sizeof(ENetProtocol)] ||
-                buffer >= &host->buffers[sizeof(host->buffers) / sizeof(ENetBuffer)] ||
-                peer->mtu - host->packetSize < sizeof(ENetProtocolAcknowledge)
-            ) {
-                host->continueSending = 1;
-                break;
-            }
-
-            acknowledgement = (ENetAcknowledgement *)currentAcknowledgement;
-            currentAcknowledgement = enet_list_next(currentAcknowledgement);
-
-            buffer->data       = command;
-            buffer->dataLength = sizeof(ENetProtocolAcknowledge);
-            host->packetSize += buffer->dataLength;
-
-            reliableSequenceNumber = ENET_HOST_TO_NET_16(acknowledgement->command.header.reliableSequenceNumber);
-
-            command->header.command   = ENET_PROTOCOL_COMMAND_ACKNOWLEDGE;
-            command->header.channelID = acknowledgement->command.header.channelID;
-            command->header.reliableSequenceNumber = reliableSequenceNumber;
-            command->acknowledge.receivedReliableSequenceNumber = reliableSequenceNumber;
-            command->acknowledge.receivedSentTime = ENET_HOST_TO_NET_16(acknowledgement->sentTime);
-
-            if ((acknowledgement->command.header.command & ENET_PROTOCOL_COMMAND_MASK) == ENET_PROTOCOL_COMMAND_DISCONNECT) {
-                enet_protocol_dispatch_state(host, peer, ENET_PEER_STATE_ZOMBIE);
-            }
-
-            enet_list_remove(&acknowledgement->acknowledgementList);
-            enet_free(acknowledgement);
-
-            ++command;
-            ++buffer;
-        }
-
-        host->commandCount = command - host->commands;
-        host->bufferCount  = buffer - host->buffers;
-    }
-
-    static void enet_protocol_send_unreliable_outgoing_commands(ENetHost *host, ENetPeer *peer) {
-        ENetProtocol *command = &host->commands[host->commandCount];
-        ENetBuffer *buffer    = &host->buffers[host->bufferCount];
-        ENetOutgoingCommand *outgoingCommand;
-        ENetListIterator currentCommand;
-
-        currentCommand = enet_list_begin(&peer->outgoingUnreliableCommands);
-        while (currentCommand != enet_list_end(&peer->outgoingUnreliableCommands)) {
-            size_t commandSize;
-
-            outgoingCommand = (ENetOutgoingCommand *)currentCommand;
-            commandSize     = commandSizes[outgoingCommand->command.header.command & ENET_PROTOCOL_COMMAND_MASK];
-
-            if (command >= &host->commands[sizeof(host->commands) / sizeof(ENetProtocol)] ||
-                buffer + 1 >= &host->buffers[sizeof(host->buffers) / sizeof(ENetBuffer)] ||
-                peer->mtu - host->packetSize < commandSize ||
-                (outgoingCommand->packet != NULL &&
-                peer->mtu - host->packetSize < commandSize + outgoingCommand->fragmentLength)
-            ) {
-                host->continueSending = 1;
-                break;
-            }
-
-            currentCommand = enet_list_next(currentCommand);
-
-            if (outgoingCommand->packet != NULL && outgoingCommand->fragmentOffset == 0) {
-                peer->packetThrottleCounter += ENET_PEER_PACKET_THROTTLE_COUNTER;
-                peer->packetThrottleCounter %= ENET_PEER_PACKET_THROTTLE_SCALE;
-
-                if (peer->packetThrottleCounter > peer->packetThrottle) {
-                    enet_uint16 reliableSequenceNumber = outgoingCommand->reliableSequenceNumber;
-                    enet_uint16 unreliableSequenceNumber = outgoingCommand->unreliableSequenceNumber;
-
-                    for (;;) {
-                        --outgoingCommand->packet->referenceCount;
-
-                        if (outgoingCommand->packet->referenceCount == 0) {
-                            enet_packet_destroy(outgoingCommand->packet);
-                        }
-
-                        enet_list_remove(&outgoingCommand->outgoingCommandList);
-                        enet_free(outgoingCommand);
-
-                        if (currentCommand == enet_list_end(&peer->outgoingUnreliableCommands)) {
-                            break;
-                        }
-
-                        outgoingCommand = (ENetOutgoingCommand *)currentCommand;
-
-                        if (outgoingCommand->reliableSequenceNumber != reliableSequenceNumber || outgoingCommand->unreliableSequenceNumber != unreliableSequenceNumber) {
-                            break;
-                        }
-
-                        currentCommand = enet_list_next(currentCommand);
-                    }
-
-                    continue;
-                }
-            }
-
-            buffer->data       = command;
-            buffer->dataLength = commandSize;
-            host->packetSize += buffer->dataLength;
-            *command = outgoingCommand->command;
-            enet_list_remove(&outgoingCommand->outgoingCommandList);
-
-            if (outgoingCommand->packet != NULL) {
-                ++buffer;
-
-                buffer->data       = outgoingCommand->packet->data + outgoingCommand->fragmentOffset;
-                buffer->dataLength = outgoingCommand->fragmentLength;
-
-                host->packetSize += buffer->dataLength;
-
-                enet_list_insert(enet_list_end(&peer->sentUnreliableCommands), outgoingCommand);
-            } else {
-                enet_free(outgoingCommand);
-            }
-
-            ++command;
-            ++buffer;
-        }
-
-        host->commandCount = command - host->commands;
-        host->bufferCount  = buffer - host->buffers;
-
-        if (peer->state == ENET_PEER_STATE_DISCONNECT_LATER &&
-          enet_list_empty(&peer->outgoingReliableCommands) &&
-          enet_list_empty(&peer->outgoingUnreliableCommands) &&
-          enet_list_empty(&peer->sentReliableCommands))
-        {
-            enet_peer_disconnect(peer, peer->eventData);
-        }
-    }
-
-    static int enet_protocol_check_timeouts(ENetHost *host, ENetPeer *peer, ENetEvent *event) {
-        ENetOutgoingCommand *outgoingCommand;
-        ENetListIterator currentCommand, insertPosition;
-
-        currentCommand = enet_list_begin(&peer->sentReliableCommands);
-        insertPosition = enet_list_begin(&peer->outgoingReliableCommands);
-
-        while (currentCommand != enet_list_end(&peer->sentReliableCommands)) {
-            outgoingCommand = (ENetOutgoingCommand *)currentCommand;
-
-            currentCommand = enet_list_next(currentCommand);
-
-            if (ENET_TIME_DIFFERENCE(host->serviceTime, outgoingCommand->sentTime) < outgoingCommand->roundTripTimeout) {
-                continue;
-            }
-
-            if (peer->earliestTimeout == 0 || ENET_TIME_LESS(outgoingCommand->sentTime, peer->earliestTimeout)) {
-                peer->earliestTimeout = outgoingCommand->sentTime;
-            }
-
-            if (peer->earliestTimeout != 0 &&
-                (ENET_TIME_DIFFERENCE(host->serviceTime, peer->earliestTimeout) >= peer->timeoutMaximum ||
-                (outgoingCommand->roundTripTimeout >= outgoingCommand->roundTripTimeoutLimit &&
-                ENET_TIME_DIFFERENCE(host->serviceTime, peer->earliestTimeout) >= peer->timeoutMinimum))
-            ) {
-                enet_protocol_notify_disconnect_timeout(host, peer, event);
-                return 1;
-            }
-
-            if (outgoingCommand->packet != NULL) {
-                peer->reliableDataInTransit -= outgoingCommand->fragmentLength;
-            }
-
-            ++peer->packetsLost;
-            ++peer->totalPacketsLost;
-
-            outgoingCommand->roundTripTimeout = peer->roundTripTime + 4 * peer->roundTripTimeVariance;
-            outgoingCommand->roundTripTimeoutLimit = peer->timeoutLimit * outgoingCommand->roundTripTimeout;
-
-            enet_list_insert(insertPosition, enet_list_remove(&outgoingCommand->outgoingCommandList));
-
-            if (currentCommand == enet_list_begin(&peer->sentReliableCommands) && !enet_list_empty(&peer->sentReliableCommands)) {
-                outgoingCommand = (ENetOutgoingCommand *)currentCommand;
-                peer->nextTimeout = outgoingCommand->sentTime + outgoingCommand->roundTripTimeout;
-            }
-        }
-
-        return 0;
-    }
-
-    static int enet_protocol_send_reliable_outgoing_commands(ENetHost *host, ENetPeer *peer) {
-        ENetProtocol *command = &host->commands[host->commandCount];
-        ENetBuffer *buffer    = &host->buffers[host->bufferCount];
-        ENetOutgoingCommand *outgoingCommand;
-        ENetListIterator currentCommand;
-        ENetChannel *channel;
-        enet_uint16 reliableWindow;
-        size_t commandSize;
-        int windowExceeded = 0, windowWrap = 0, canPing = 1;
-
-        currentCommand = enet_list_begin(&peer->outgoingReliableCommands);
-
-        while (currentCommand != enet_list_end(&peer->outgoingReliableCommands)) {
-            outgoingCommand = (ENetOutgoingCommand *)currentCommand;
-            channel = outgoingCommand->command.header.channelID < peer->channelCount ? &peer->channels[outgoingCommand->command.header.channelID] : NULL;
-            reliableWindow = outgoingCommand->reliableSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE;
-
-            if (channel != NULL) {
-                if (!windowWrap &&
-                    outgoingCommand->sendAttempts < 1 &&
-                    !(outgoingCommand->reliableSequenceNumber % ENET_PEER_RELIABLE_WINDOW_SIZE) &&
-                    (channel->reliableWindows[(reliableWindow + ENET_PEER_RELIABLE_WINDOWS - 1)
-                    % ENET_PEER_RELIABLE_WINDOWS] >= ENET_PEER_RELIABLE_WINDOW_SIZE ||
-                    channel->usedReliableWindows & ((((1 << ENET_PEER_FREE_RELIABLE_WINDOWS) - 1) << reliableWindow)
-                    | (((1 << ENET_PEER_FREE_RELIABLE_WINDOWS) - 1) >> (ENET_PEER_RELIABLE_WINDOWS - reliableWindow))))
-                ) {
-                    windowWrap = 1;
-                }
-
-                if (windowWrap) {
-                    currentCommand = enet_list_next(currentCommand);
-
-                    continue;
-                }
-            }
-
-            if (outgoingCommand->packet != NULL) {
-                if (!windowExceeded) {
-                    enet_uint32 windowSize = (peer->packetThrottle * peer->windowSize) / ENET_PEER_PACKET_THROTTLE_SCALE;
-
-                    if (peer->reliableDataInTransit + outgoingCommand->fragmentLength > ENET_MAX(windowSize, peer->mtu)) {
-                        windowExceeded = 1;
-                    }
-                }
-
-                if (windowExceeded) {
-                    currentCommand = enet_list_next(currentCommand);
-
-                    continue;
-                }
-            }
-
-            canPing = 0;
-
-            commandSize = commandSizes[outgoingCommand->command.header.command & ENET_PROTOCOL_COMMAND_MASK];
-
-            if (command >= &host->commands[sizeof(host->commands) / sizeof(ENetProtocol)] ||
-                buffer + 1 >= &host->buffers[sizeof(host->buffers) / sizeof(ENetBuffer)] ||
-                peer->mtu - host->packetSize < commandSize ||
-                (outgoingCommand->packet != NULL &&
-                (enet_uint16) (peer->mtu - host->packetSize) < (enet_uint16) (commandSize + outgoingCommand->fragmentLength))
-            ) {
-                host->continueSending = 1;
-                break;
-            }
-
-            currentCommand = enet_list_next(currentCommand);
-
-            if (channel != NULL && outgoingCommand->sendAttempts < 1) {
-                channel->usedReliableWindows |= 1 << reliableWindow;
-                ++channel->reliableWindows[reliableWindow];
-            }
-
-            ++outgoingCommand->sendAttempts;
-
-            if (outgoingCommand->roundTripTimeout == 0) {
-                outgoingCommand->roundTripTimeout      = peer->roundTripTime + 4 * peer->roundTripTimeVariance;
-                outgoingCommand->roundTripTimeoutLimit = peer->timeoutLimit * outgoingCommand->roundTripTimeout;
-            }
-
-            if (enet_list_empty(&peer->sentReliableCommands)) {
-                peer->nextTimeout = host->serviceTime + outgoingCommand->roundTripTimeout;
-            }
-
-            enet_list_insert(enet_list_end(&peer->sentReliableCommands), enet_list_remove(&outgoingCommand->outgoingCommandList));
-
-            outgoingCommand->sentTime = host->serviceTime;
-
-            buffer->data       = command;
-            buffer->dataLength = commandSize;
-
-            host->packetSize  += buffer->dataLength;
-            host->headerFlags |= ENET_PROTOCOL_HEADER_FLAG_SENT_TIME;
-
-            *command = outgoingCommand->command;
-
-            if (outgoingCommand->packet != NULL) {
-                ++buffer;
-                buffer->data       = outgoingCommand->packet->data + outgoingCommand->fragmentOffset;
-                buffer->dataLength = outgoingCommand->fragmentLength;
-                host->packetSize += outgoingCommand->fragmentLength;
-                peer->reliableDataInTransit += outgoingCommand->fragmentLength;
-            }
-
-            ++peer->packetsSent;
-            ++peer->totalPacketsSent;
-
-            ++command;
-            ++buffer;
-        }
-
-        host->commandCount = command - host->commands;
-        host->bufferCount  = buffer - host->buffers;
-
-        return canPing;
-    }
-
-    static int enet_protocol_send_outgoing_commands(ENetHost *host, ENetEvent *event, int checkForTimeouts) {
-        enet_uint8 headerData[sizeof(ENetProtocolHeader) + sizeof(enet_uint32)];
-        ENetProtocolHeader *header = (ENetProtocolHeader *)headerData;
-        ENetPeer *currentPeer;
-        int sentLength;
-        host->continueSending = 1;
-
-        while (host->continueSending)
-            for (host->continueSending = 0, currentPeer = host->peers; currentPeer < &host->peers[host->peerCount]; ++currentPeer) {
-                if (currentPeer->state == ENET_PEER_STATE_DISCONNECTED || currentPeer->state == ENET_PEER_STATE_ZOMBIE) {
-                    continue;
-                }
-
-                host->headerFlags  = 0;
-                host->commandCount = 0;
-                host->bufferCount  = 1;
-                host->packetSize   = sizeof(ENetProtocolHeader);
-
-                if (!enet_list_empty(&currentPeer->acknowledgements)) {
-                    enet_protocol_send_acknowledgements(host, currentPeer);
-                }
-
-                if (checkForTimeouts != 0 &&
-                    !enet_list_empty(&currentPeer->sentReliableCommands) &&
-                    ENET_TIME_GREATER_EQUAL(host->serviceTime, currentPeer->nextTimeout) &&
-                    enet_protocol_check_timeouts(host, currentPeer, event) == 1
-                ) {
-                    if (event != NULL && event->type != ENET_EVENT_TYPE_NONE) {
-                        return 1;
-                    } else {
-                        continue;
-                    }
-                }
-
-                if ((enet_list_empty(&currentPeer->outgoingReliableCommands) ||
-                    enet_protocol_send_reliable_outgoing_commands(host, currentPeer)) &&
-                    enet_list_empty(&currentPeer->sentReliableCommands) &&
-                    ENET_TIME_DIFFERENCE(host->serviceTime, currentPeer->lastReceiveTime) >= currentPeer->pingInterval &&
-                    currentPeer->mtu - host->packetSize >= sizeof(ENetProtocolPing)
-                ) {
-                    enet_peer_ping(currentPeer);
-                    enet_protocol_send_reliable_outgoing_commands(host, currentPeer);
-                }
-
-                if (!enet_list_empty(&currentPeer->outgoingUnreliableCommands)) {
-                    enet_protocol_send_unreliable_outgoing_commands(host, currentPeer);
-                }
-
-                if (host->commandCount == 0) {
-                    continue;
-                }
-
-                if (currentPeer->packetLossEpoch == 0) {
-                    currentPeer->packetLossEpoch = host->serviceTime;
-                } else if (ENET_TIME_DIFFERENCE(host->serviceTime, currentPeer->packetLossEpoch) >= ENET_PEER_PACKET_LOSS_INTERVAL && currentPeer->packetsSent > 0) {
-                    enet_uint32 packetLoss = currentPeer->packetsLost * ENET_PEER_PACKET_LOSS_SCALE / currentPeer->packetsSent;
-
-                    #ifdef ENET_DEBUG
-                        printf(
-                            "peer %u: %f%%+-%f%% packet loss, %u+-%u ms round trip time, %f%% throttle, %u/%u outgoing, %u/%u incoming\n", currentPeer->incomingPeerID,
-                            currentPeer->packetLoss / (float) ENET_PEER_PACKET_LOSS_SCALE,
-                            currentPeer->packetLossVariance / (float) ENET_PEER_PACKET_LOSS_SCALE, currentPeer->roundTripTime, currentPeer->roundTripTimeVariance,
-                            currentPeer->packetThrottle / (float) ENET_PEER_PACKET_THROTTLE_SCALE,
-                            enet_list_size(&currentPeer->outgoingReliableCommands),
-                            enet_list_size(&currentPeer->outgoingUnreliableCommands),
-                            currentPeer->channels != NULL ? enet_list_size( &currentPeer->channels->incomingReliableCommands) : 0,
-                            currentPeer->channels != NULL ? enet_list_size(&currentPeer->channels->incomingUnreliableCommands) : 0
-                        );
-                    #endif
-
-                    currentPeer->packetLossVariance -= currentPeer->packetLossVariance / 4;
-
-                    if (packetLoss >= currentPeer->packetLoss) {
-                        currentPeer->packetLoss         += (packetLoss - currentPeer->packetLoss) / 8;
-                        currentPeer->packetLossVariance += (packetLoss - currentPeer->packetLoss) / 4;
-                    } else {
-                        currentPeer->packetLoss         -= (currentPeer->packetLoss - packetLoss) / 8;
-                        currentPeer->packetLossVariance += (currentPeer->packetLoss - packetLoss) / 4;
-                    }
-
-                    currentPeer->packetLossEpoch = host->serviceTime;
-                    currentPeer->packetsSent     = 0;
-                    currentPeer->packetsLost     = 0;
-                }
-
-                host->buffers->data = headerData;
-
-                if (host->headerFlags & ENET_PROTOCOL_HEADER_FLAG_SENT_TIME) {
-                    header->sentTime = ENET_HOST_TO_NET_16(host->serviceTime & 0xFFFF);
-                    host->buffers->dataLength = sizeof(ENetProtocolHeader);
-                } else {
-                    host->buffers->dataLength = (size_t) &((ENetProtocolHeader *)0)->sentTime;
-                }
-
-                if (currentPeer->outgoingPeerID < ENET_PROTOCOL_MAXIMUM_PEER_ID) {
-                    host->headerFlags |= currentPeer->outgoingSessionID << ENET_PROTOCOL_HEADER_SESSION_SHIFT;
-                }
-
-                header->peerID = ENET_HOST_TO_NET_16(currentPeer->outgoingPeerID | host->headerFlags);
-
-                if (host->checksum != NULL) {
-                    enet_uint32 *checksum = (enet_uint32 *)&headerData[host->buffers->dataLength];
-                    *checksum = currentPeer->outgoingPeerID < ENET_PROTOCOL_MAXIMUM_PEER_ID ? currentPeer->connectID : 0;
-                    host->buffers->dataLength += sizeof(enet_uint32);
-                    *checksum = host->checksum(host->buffers, host->bufferCount);
-                }
-
-                currentPeer->lastSendTime = host->serviceTime;
-                sentLength = enet_socket_send(host->socket, &currentPeer->address, host->buffers, host->bufferCount);
-                enet_protocol_remove_sent_unreliable_commands(currentPeer);
-
-                if (sentLength < 0) {
-                    return -1;
-                }
-
-                host->totalSentData += sentLength;
-                currentPeer->totalDataSent += sentLength;
-                host->totalSentPackets++;
-            }
-
-        return 0;
-    }
-
-    void enet_host_flush(ENetHost *host) {
-        host->serviceTime = enet_time_get();
-        enet_protocol_send_outgoing_commands(host, NULL, 0);
-    }
-
-    int enet_host_check_events(ENetHost *host, ENetEvent *event) {
-        if (event == NULL) {
-            return -1;
-        }
-
-        event->type   = ENET_EVENT_TYPE_NONE;
-        event->peer   = NULL;
-        event->packet = NULL;
-
-        return enet_protocol_dispatch_incoming_commands(host, event);
-    }
-
-    int enet_host_service(ENetHost *host, ENetEvent *event, enet_uint32 timeout) {
-        enet_uint32 waitCondition;
-
-        if (event != NULL) {
-            event->type   = ENET_EVENT_TYPE_NONE;
-            event->peer   = NULL;
-            event->packet = NULL;
-
-            switch (enet_protocol_dispatch_incoming_commands(host, event)) {
-                case 1:
-                    return 1;
-
-                case -1:
-                    #ifdef ENET_DEBUG
-                        perror("Error dispatching incoming packets");
-                    #endif
-
-                    return -1;
-
-                default:
-                    break;
-            }
-        }
-
-        host->serviceTime = enet_time_get();
-        timeout += host->serviceTime;
-
-        do {
-            if (ENET_TIME_DIFFERENCE(host->serviceTime, host->bandwidthThrottleEpoch) >= ENET_HOST_BANDWIDTH_THROTTLE_INTERVAL) {
-                enet_host_bandwidth_throttle(host);
-            }
-
-            switch (enet_protocol_send_outgoing_commands(host, event, 1)) {
-                case 1:
-                    return 1;
-
-                case -1:
-                    #ifdef ENET_DEBUG
-                        perror("Error sending outgoing packets");
-                    #endif
-
-                    return -1;
-
-                default:
-                    break;
-            }
-
-            switch (enet_protocol_receive_incoming_commands(host, event)) {
-                case 1:
-                    return 1;
-
-                case -1:
-                    #ifdef ENET_DEBUG
-                        perror("Error receiving incoming packets");
-                    #endif
-
-                    return -1;
-
-                default:
-                    break;
-            }
-
-            switch (enet_protocol_send_outgoing_commands(host, event, 1)) {
-                case 1:
-                    return 1;
-
-                case -1:
-                    #ifdef ENET_DEBUG
-                        perror("Error sending outgoing packets");
-                    #endif
-
-                    return -1;
-
-                default:
-                    break;
-            }
-
-            if (event != NULL) {
-                switch (enet_protocol_dispatch_incoming_commands(host, event)) {
-                    case 1:
-                        return 1;
-
-                    case -1:
-                        #ifdef ENET_DEBUG
-                            perror("Error dispatching incoming packets");
-                        #endif
-
-                        return -1;
-
-                    default:
-                        break;
-                }
-            }
-
-            if (ENET_TIME_GREATER_EQUAL(host->serviceTime, timeout)) {
-                return 0;
-            }
-
-            do {
-                host->serviceTime = enet_time_get();
-
-                if (ENET_TIME_GREATER_EQUAL(host->serviceTime, timeout)) {
-                    return 0;
-                }
-
-                waitCondition = ENET_SOCKET_WAIT_RECEIVE | ENET_SOCKET_WAIT_INTERRUPT;
-
-                if (enet_socket_wait(host->socket, &waitCondition, ENET_TIME_DIFFERENCE(timeout, host->serviceTime)) != 0) {
-                    return -1;
-                }
-            } while (waitCondition & ENET_SOCKET_WAIT_INTERRUPT);
-
-            host->serviceTime = enet_time_get();
-        } while (waitCondition & ENET_SOCKET_WAIT_RECEIVE);
-
-        return 0;
-    }
-
-// =======================================================================//
-// !
-// ! Peer
-// !
-// =======================================================================//
-
-    void enet_peer_throttle_configure(ENetPeer *peer, enet_uint32 interval, enet_uint32 acceleration, enet_uint32 deceleration) {
-        ENetProtocol command;
-
-        peer->packetThrottleInterval     = interval;
-        peer->packetThrottleAcceleration = acceleration;
-        peer->packetThrottleDeceleration = deceleration;
-
-        command.header.command   = ENET_PROTOCOL_COMMAND_THROTTLE_CONFIGURE | ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE;
-        command.header.channelID = 0xFF;
-
-        command.throttleConfigure.packetThrottleInterval     = ENET_HOST_TO_NET_32(interval);
-        command.throttleConfigure.packetThrottleAcceleration = ENET_HOST_TO_NET_32(acceleration);
-        command.throttleConfigure.packetThrottleDeceleration = ENET_HOST_TO_NET_32(deceleration);
-
-        enet_peer_queue_outgoing_command(peer, &command, NULL, 0, 0);
-    }
-
-    int enet_peer_throttle(ENetPeer *peer, enet_uint32 rtt) {
-        if (peer->lastRoundTripTime <= peer->lastRoundTripTimeVariance) {
-            peer->packetThrottle = peer->packetThrottleLimit;
-        } else if (rtt < peer->lastRoundTripTime) {
-            peer->packetThrottle += peer->packetThrottleAcceleration;
-
-            if (peer->packetThrottle > peer->packetThrottleLimit) {
-                peer->packetThrottle = peer->packetThrottleLimit;
-            }
-
-            return 1;
-        } else if (rtt > peer->lastRoundTripTime + 2 * peer->lastRoundTripTimeVariance) {
-            if (peer->packetThrottle > peer->packetThrottleDeceleration) {
-                peer->packetThrottle -= peer->packetThrottleDeceleration;
-            } else {
-                peer->packetThrottle = 0;
-            }
-
-            return -1;
-        }
-
-        return 0;
-    }
-
-    int enet_peer_send(ENetPeer *peer, enet_uint8 channelID, ENetPacket *packet) {
-        ENetChannel *channel = &peer->channels[channelID];
-        ENetProtocol command;
-        size_t fragmentLength;
-
-        if (peer->state != ENET_PEER_STATE_CONNECTED || channelID >= peer->channelCount || packet->dataLength > peer->host->maximumPacketSize) {
-            return -1;
-        }
-
-        fragmentLength = peer->mtu - sizeof(ENetProtocolHeader) - sizeof(ENetProtocolSendFragment);
-
-        if (peer->host->checksum != NULL) {
-            fragmentLength -= sizeof(enet_uint32);
-        }
-
-        if (packet->dataLength > fragmentLength) {
-            enet_uint32 fragmentCount = (packet->dataLength + fragmentLength - 1) / fragmentLength, fragmentNumber, fragmentOffset;
-            enet_uint8 commandNumber;
-            enet_uint16 startSequenceNumber;
-            ENetList fragments;
-            ENetOutgoingCommand *fragment;
-
-            if (fragmentCount > ENET_PROTOCOL_MAXIMUM_FRAGMENT_COUNT) {
-                return -1;
-            }
-
-            if ((packet->flags & (ENET_PACKET_FLAG_RELIABLE | ENET_PACKET_FLAG_UNRELIABLE_FRAGMENT)) == ENET_PACKET_FLAG_UNRELIABLE_FRAGMENT && channel->outgoingUnreliableSequenceNumber < 0xFFFF) {
-                commandNumber       = ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE_FRAGMENT;
-                startSequenceNumber = ENET_HOST_TO_NET_16(channel->outgoingUnreliableSequenceNumber + 1);
-            } else {
-                commandNumber       = ENET_PROTOCOL_COMMAND_SEND_FRAGMENT | ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE;
-                startSequenceNumber = ENET_HOST_TO_NET_16(channel->outgoingReliableSequenceNumber + 1);
-            }
-
-            enet_list_clear(&fragments);
-
-            for (fragmentNumber = 0, fragmentOffset = 0; fragmentOffset < packet->dataLength; ++fragmentNumber, fragmentOffset += fragmentLength) {
-                if (packet->dataLength - fragmentOffset < fragmentLength) {
-                    fragmentLength = packet->dataLength - fragmentOffset;
-                }
-
-                fragment = (ENetOutgoingCommand *)enet_malloc(sizeof(ENetOutgoingCommand));
-
-                if (fragment == NULL) {
-                    while (!enet_list_empty(&fragments)) {
-                        fragment = (ENetOutgoingCommand *)enet_list_remove(enet_list_begin(&fragments));
-
-                        enet_free(fragment);
-                    }
-
-                    return -1;
-                }
-
-                fragment->fragmentOffset           = fragmentOffset;
-                fragment->fragmentLength           = fragmentLength;
-                fragment->packet                   = packet;
-                fragment->command.header.command   = commandNumber;
-                fragment->command.header.channelID = channelID;
-
-                fragment->command.sendFragment.startSequenceNumber = startSequenceNumber;
-
-                fragment->command.sendFragment.dataLength     = ENET_HOST_TO_NET_16(fragmentLength);
-                fragment->command.sendFragment.fragmentCount  = ENET_HOST_TO_NET_32(fragmentCount);
-                fragment->command.sendFragment.fragmentNumber = ENET_HOST_TO_NET_32(fragmentNumber);
-                fragment->command.sendFragment.totalLength    = ENET_HOST_TO_NET_32(packet->dataLength);
-                fragment->command.sendFragment.fragmentOffset = ENET_NET_TO_HOST_32(fragmentOffset);
-
-                enet_list_insert(enet_list_end(&fragments), fragment);
-            }
-
-            packet->referenceCount += fragmentNumber;
-
-            while (!enet_list_empty(&fragments)) {
-                fragment = (ENetOutgoingCommand *)enet_list_remove(enet_list_begin(&fragments));
-                enet_peer_setup_outgoing_command(peer, fragment);
-            }
-
-            return 0;
-        }
-
-        command.header.channelID = channelID;
-
-        if ((packet->flags & (ENET_PACKET_FLAG_RELIABLE | ENET_PACKET_FLAG_UNSEQUENCED)) == ENET_PACKET_FLAG_UNSEQUENCED) {
-            command.header.command = ENET_PROTOCOL_COMMAND_SEND_UNSEQUENCED | ENET_PROTOCOL_COMMAND_FLAG_UNSEQUENCED;
-            command.sendUnsequenced.dataLength = ENET_HOST_TO_NET_16(packet->dataLength);
-        } else if (packet->flags & ENET_PACKET_FLAG_RELIABLE || channel->outgoingUnreliableSequenceNumber >= 0xFFFF) {
-            command.header.command = ENET_PROTOCOL_COMMAND_SEND_RELIABLE | ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE;
-            command.sendReliable.dataLength = ENET_HOST_TO_NET_16(packet->dataLength);
-        } else {
-            command.header.command = ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE;
-            command.sendUnreliable.dataLength = ENET_HOST_TO_NET_16(packet->dataLength);
-        }
-
-        if (enet_peer_queue_outgoing_command(peer, &command, packet, 0, packet->dataLength) == NULL) {
-            return -1;
-        }
-
-        return 0;
-    }
-
-    ENetPacket * enet_peer_receive(ENetPeer *peer, enet_uint8 *channelID) {
-        ENetIncomingCommand *incomingCommand;
-        ENetPacket *packet;
-
-        if (enet_list_empty(&peer->dispatchedCommands)) {
-            return NULL;
-        }
-
-        incomingCommand = (ENetIncomingCommand *)enet_list_remove(enet_list_begin(&peer->dispatchedCommands));
-
-        if (channelID != NULL) {
-            *channelID = incomingCommand->command.header.channelID;
-        }
-
-        packet = incomingCommand->packet;
-        --packet->referenceCount;
-
-        if (incomingCommand->fragments != NULL) {
-            enet_free(incomingCommand->fragments);
-        }
-
-        enet_free(incomingCommand);
-        peer->totalWaitingData -= packet->dataLength;
-
-        return packet;
-    }
-
-    static void enet_peer_reset_outgoing_commands(ENetList *queue) {
-        ENetOutgoingCommand *outgoingCommand;
-
-        while (!enet_list_empty(queue)) {
-            outgoingCommand = (ENetOutgoingCommand *)enet_list_remove(enet_list_begin(queue));
-
-            if (outgoingCommand->packet != NULL) {
-                --outgoingCommand->packet->referenceCount;
-
-                if (outgoingCommand->packet->referenceCount == 0) {
-                    enet_packet_destroy(outgoingCommand->packet);
-                }
-            }
-
-            enet_free(outgoingCommand);
-        }
-    }
-
-    static void enet_peer_remove_incoming_commands(ENetList *queue, ENetListIterator startCommand, ENetListIterator endCommand) {
-        ENetListIterator currentCommand;
-
-        for (currentCommand = startCommand; currentCommand != endCommand;) {
-            ENetIncomingCommand *incomingCommand = (ENetIncomingCommand *)currentCommand;
-
-            currentCommand = enet_list_next(currentCommand);
-            enet_list_remove(&incomingCommand->incomingCommandList);
-
-            if (incomingCommand->packet != NULL) {
-                --incomingCommand->packet->referenceCount;
-
-                if (incomingCommand->packet->referenceCount == 0) {
-                    enet_packet_destroy(incomingCommand->packet);
-                }
-            }
-
-            if (incomingCommand->fragments != NULL) {
-                enet_free(incomingCommand->fragments);
-            }
-
-            enet_free(incomingCommand);
-        }
-    }
-
-    static void enet_peer_reset_incoming_commands(ENetList *queue) {
-        enet_peer_remove_incoming_commands(queue, enet_list_begin(queue), enet_list_end(queue));
-    }
-
-    void enet_peer_reset_queues(ENetPeer *peer) {
-        ENetChannel *channel;
-
-        if (peer->needsDispatch) {
-            enet_list_remove(&peer->dispatchList);
-            peer->needsDispatch = 0;
-        }
-
-        while (!enet_list_empty(&peer->acknowledgements)) {
-            enet_free(enet_list_remove(enet_list_begin(&peer->acknowledgements)));
-        }
-
-        enet_peer_reset_outgoing_commands(&peer->sentReliableCommands);
-        enet_peer_reset_outgoing_commands(&peer->sentUnreliableCommands);
-        enet_peer_reset_outgoing_commands(&peer->outgoingReliableCommands);
-        enet_peer_reset_outgoing_commands(&peer->outgoingUnreliableCommands);
-        enet_peer_reset_incoming_commands(&peer->dispatchedCommands);
-
-        if (peer->channels != NULL && peer->channelCount > 0) {
-            for (channel = peer->channels; channel < &peer->channels[peer->channelCount]; ++channel) {
-                enet_peer_reset_incoming_commands(&channel->incomingReliableCommands);
-                enet_peer_reset_incoming_commands(&channel->incomingUnreliableCommands);
-            }
-
-            enet_free(peer->channels);
-        }
-
-        peer->channels     = NULL;
-        peer->channelCount = 0;
-    }
-
-    void enet_peer_on_connect(ENetPeer *peer) {
-        if (peer->state != ENET_PEER_STATE_CONNECTED && peer->state != ENET_PEER_STATE_DISCONNECT_LATER) {
-            if (peer->incomingBandwidth != 0) {
-                ++peer->host->bandwidthLimitedPeers;
-            }
-
-            ++peer->host->connectedPeers;
-        }
-    }
-
-    void enet_peer_on_disconnect(ENetPeer *peer) {
-        if (peer->state == ENET_PEER_STATE_CONNECTED || peer->state == ENET_PEER_STATE_DISCONNECT_LATER) {
-            if (peer->incomingBandwidth != 0) {
-                --peer->host->bandwidthLimitedPeers;
-            }
-
-            --peer->host->connectedPeers;
-        }
-    }
-
-    void enet_peer_reset(ENetPeer *peer) {
-        enet_peer_on_disconnect(peer);
-
-        peer->outgoingPeerID                 = ENET_PROTOCOL_MAXIMUM_PEER_ID;
-        peer->state                          = ENET_PEER_STATE_DISCONNECTED;
-        peer->incomingBandwidth              = 0;
-        peer->outgoingBandwidth              = 0;
-        peer->incomingBandwidthThrottleEpoch = 0;
-        peer->outgoingBandwidthThrottleEpoch = 0;
-        peer->incomingDataTotal              = 0;
-        peer->totalDataReceived              = 0;
-        peer->outgoingDataTotal              = 0;
-        peer->totalDataSent                  = 0;
-        peer->lastSendTime                   = 0;
-        peer->lastReceiveTime                = 0;
-        peer->nextTimeout                    = 0;
-        peer->earliestTimeout                = 0;
-        peer->packetLossEpoch                = 0;
-        peer->packetsSent                    = 0;
-        peer->totalPacketsSent               = 0;
-        peer->packetsLost                    = 0;
-        peer->totalPacketsLost               = 0;
-        peer->packetLoss                     = 0;
-        peer->packetLossVariance             = 0;
-        peer->packetThrottle                 = ENET_PEER_DEFAULT_PACKET_THROTTLE;
-        peer->packetThrottleLimit            = ENET_PEER_PACKET_THROTTLE_SCALE;
-        peer->packetThrottleCounter          = 0;
-        peer->packetThrottleEpoch            = 0;
-        peer->packetThrottleAcceleration     = ENET_PEER_PACKET_THROTTLE_ACCELERATION;
-        peer->packetThrottleDeceleration     = ENET_PEER_PACKET_THROTTLE_DECELERATION;
-        peer->packetThrottleInterval         = ENET_PEER_PACKET_THROTTLE_INTERVAL;
-        peer->pingInterval                   = ENET_PEER_PING_INTERVAL;
-        peer->timeoutLimit                   = ENET_PEER_TIMEOUT_LIMIT;
-        peer->timeoutMinimum                 = ENET_PEER_TIMEOUT_MINIMUM;
-        peer->timeoutMaximum                 = ENET_PEER_TIMEOUT_MAXIMUM;
-        peer->lastRoundTripTime              = ENET_PEER_DEFAULT_ROUND_TRIP_TIME;
-        peer->lowestRoundTripTime            = ENET_PEER_DEFAULT_ROUND_TRIP_TIME;
-        peer->lastRoundTripTimeVariance      = 0;
-        peer->highestRoundTripTimeVariance   = 0;
-        peer->roundTripTime                  = ENET_PEER_DEFAULT_ROUND_TRIP_TIME;
-        peer->roundTripTimeVariance          = 0;
-        peer->mtu                            = peer->host->mtu;
-        peer->reliableDataInTransit          = 0;
-        peer->outgoingReliableSequenceNumber = 0;
-        peer->windowSize                     = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
-        peer->incomingUnsequencedGroup       = 0;
-        peer->outgoingUnsequencedGroup       = 0;
-        peer->eventData                      = 0;
-        peer->totalWaitingData               = 0;
-
-        memset(peer->unsequencedWindow, 0, sizeof(peer->unsequencedWindow));
-        enet_peer_reset_queues(peer);
-    }
-
-    void enet_peer_ping(ENetPeer *peer) {
-        ENetProtocol command;
-
-        if (peer->state != ENET_PEER_STATE_CONNECTED) {
-            return;
-        }
-
-        command.header.command   = ENET_PROTOCOL_COMMAND_PING | ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE;
-        command.header.channelID = 0xFF;
-
-        enet_peer_queue_outgoing_command(peer, &command, NULL, 0, 0);
-    }
-
-    void enet_peer_ping_interval(ENetPeer *peer, enet_uint32 pingInterval) {
-        peer->pingInterval = pingInterval ? pingInterval : ENET_PEER_PING_INTERVAL;
-    }
-
-    void enet_peer_timeout(ENetPeer *peer, enet_uint32 timeoutLimit, enet_uint32 timeoutMinimum, enet_uint32 timeoutMaximum) {
-        peer->timeoutLimit   = timeoutLimit ? timeoutLimit : ENET_PEER_TIMEOUT_LIMIT;
-        peer->timeoutMinimum = timeoutMinimum ? timeoutMinimum : ENET_PEER_TIMEOUT_MINIMUM;
-        peer->timeoutMaximum = timeoutMaximum ? timeoutMaximum : ENET_PEER_TIMEOUT_MAXIMUM;
-    }
-
-    void enet_peer_disconnect_now(ENetPeer *peer, enet_uint32 data) {
-        ENetProtocol command;
-
-        if (peer->state == ENET_PEER_STATE_DISCONNECTED) {
-            return;
-        }
-
-        if (peer->state != ENET_PEER_STATE_ZOMBIE && peer->state != ENET_PEER_STATE_DISCONNECTING) {
-            enet_peer_reset_queues(peer);
-
-            command.header.command   = ENET_PROTOCOL_COMMAND_DISCONNECT | ENET_PROTOCOL_COMMAND_FLAG_UNSEQUENCED;
-            command.header.channelID = 0xFF;
-            command.disconnect.data  = ENET_HOST_TO_NET_32(data);
-
-            enet_peer_queue_outgoing_command(peer, &command, NULL, 0, 0);
-            enet_host_flush(peer->host);
-        }
-
-        enet_peer_reset(peer);
-    }
-
-    void enet_peer_disconnect(ENetPeer *peer, enet_uint32 data) {
-        ENetProtocol command;
-
-        if (peer->state == ENET_PEER_STATE_DISCONNECTING ||
-            peer->state == ENET_PEER_STATE_DISCONNECTED ||
-            peer->state == ENET_PEER_STATE_ACKNOWLEDGING_DISCONNECT ||
-            peer->state == ENET_PEER_STATE_ZOMBIE
-        ) {
-            return;
-        }
-
-        enet_peer_reset_queues(peer);
-
-        command.header.command   = ENET_PROTOCOL_COMMAND_DISCONNECT;
-        command.header.channelID = 0xFF;
-        command.disconnect.data  = ENET_HOST_TO_NET_32(data);
-
-        if (peer->state == ENET_PEER_STATE_CONNECTED || peer->state == ENET_PEER_STATE_DISCONNECT_LATER) {
-            command.header.command |= ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE;
-        } else {
-            command.header.command |= ENET_PROTOCOL_COMMAND_FLAG_UNSEQUENCED;
-        }
-
-        enet_peer_queue_outgoing_command(peer, &command, NULL, 0, 0);
-
-        if (peer->state == ENET_PEER_STATE_CONNECTED || peer->state == ENET_PEER_STATE_DISCONNECT_LATER) {
-            enet_peer_on_disconnect(peer);
-
-            peer->state = ENET_PEER_STATE_DISCONNECTING;
-        } else {
-            enet_host_flush(peer->host);
-            enet_peer_reset(peer);
-        }
-    }
-
-    void enet_peer_disconnect_later(ENetPeer *peer, enet_uint32 data) {
-        if ((peer->state == ENET_PEER_STATE_CONNECTED || peer->state == ENET_PEER_STATE_DISCONNECT_LATER) &&
-            !(enet_list_empty(&peer->outgoingReliableCommands) &&
-            enet_list_empty(&peer->outgoingUnreliableCommands) &&
-            enet_list_empty(&peer->sentReliableCommands))
-        ) {
-            peer->state     = ENET_PEER_STATE_DISCONNECT_LATER;
-            peer->eventData = data;
-        } else {
-            enet_peer_disconnect(peer, data);
-        }
-    }
-
-    ENetAcknowledgement *enet_peer_queue_acknowledgement(ENetPeer *peer, const ENetProtocol *command, enet_uint16 sentTime) {
-        ENetAcknowledgement *acknowledgement;
-
-        if (command->header.channelID < peer->channelCount) {
-            ENetChannel *channel       = &peer->channels[command->header.channelID];
-            enet_uint16 reliableWindow = command->header.reliableSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE;
-            enet_uint16 currentWindow  = channel->incomingReliableSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE;
-
-            if (command->header.reliableSequenceNumber < channel->incomingReliableSequenceNumber) {
-                reliableWindow += ENET_PEER_RELIABLE_WINDOWS;
-            }
-
-            if (reliableWindow >= currentWindow + ENET_PEER_FREE_RELIABLE_WINDOWS - 1 && reliableWindow <= currentWindow + ENET_PEER_FREE_RELIABLE_WINDOWS) {
-                return NULL;
-            }
-        }
-
-        acknowledgement = (ENetAcknowledgement *)enet_malloc(sizeof(ENetAcknowledgement));
-
-        if (acknowledgement == NULL) {
-            return NULL;
-        }
-
-        peer->outgoingDataTotal += sizeof(ENetProtocolAcknowledge);
-
-        acknowledgement->sentTime = sentTime;
-        acknowledgement->command  = *command;
-
-        enet_list_insert(enet_list_end(&peer->acknowledgements), acknowledgement);
-
-        return acknowledgement;
-    }
-
-    void enet_peer_setup_outgoing_command(ENetPeer *peer, ENetOutgoingCommand *outgoingCommand) {
-        ENetChannel *channel = &peer->channels[outgoingCommand->command.header.channelID];
-        peer->outgoingDataTotal += enet_protocol_command_size(outgoingCommand->command.header.command) + outgoingCommand->fragmentLength;
-
-        if (outgoingCommand->command.header.channelID == 0xFF) {
-            ++peer->outgoingReliableSequenceNumber;
-
-            outgoingCommand->reliableSequenceNumber   = peer->outgoingReliableSequenceNumber;
-            outgoingCommand->unreliableSequenceNumber = 0;
-        } else if (outgoingCommand->command.header.command & ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE) {
-            ++channel->outgoingReliableSequenceNumber;
-            channel->outgoingUnreliableSequenceNumber = 0;
-
-            outgoingCommand->reliableSequenceNumber   = channel->outgoingReliableSequenceNumber;
-            outgoingCommand->unreliableSequenceNumber = 0;
-        } else if (outgoingCommand->command.header.command & ENET_PROTOCOL_COMMAND_FLAG_UNSEQUENCED) {
-            ++peer->outgoingUnsequencedGroup;
-
-            outgoingCommand->reliableSequenceNumber   = 0;
-            outgoingCommand->unreliableSequenceNumber = 0;
-        } else {
-            if (outgoingCommand->fragmentOffset == 0) {
-                ++channel->outgoingUnreliableSequenceNumber;
-            }
-
-            outgoingCommand->reliableSequenceNumber   = channel->outgoingReliableSequenceNumber;
-            outgoingCommand->unreliableSequenceNumber = channel->outgoingUnreliableSequenceNumber;
-        }
-
-        outgoingCommand->sendAttempts          = 0;
-        outgoingCommand->sentTime              = 0;
-        outgoingCommand->roundTripTimeout      = 0;
-        outgoingCommand->roundTripTimeoutLimit = 0;
-        outgoingCommand->command.header.reliableSequenceNumber = ENET_HOST_TO_NET_16(outgoingCommand->reliableSequenceNumber);
-
-        switch (outgoingCommand->command.header.command & ENET_PROTOCOL_COMMAND_MASK) {
-            case ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE:
-                outgoingCommand->command.sendUnreliable.unreliableSequenceNumber = ENET_HOST_TO_NET_16(outgoingCommand->unreliableSequenceNumber);
-                break;
-
-            case ENET_PROTOCOL_COMMAND_SEND_UNSEQUENCED:
-                outgoingCommand->command.sendUnsequenced.unsequencedGroup = ENET_HOST_TO_NET_16(peer->outgoingUnsequencedGroup);
-                break;
-
-            default:
-                break;
-        }
-
-        if (outgoingCommand->command.header.command & ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE) {
-            enet_list_insert(enet_list_end(&peer->outgoingReliableCommands), outgoingCommand);
-        } else {
-            enet_list_insert(enet_list_end(&peer->outgoingUnreliableCommands), outgoingCommand);
-        }
-    }
-
-    ENetOutgoingCommand * enet_peer_queue_outgoing_command(ENetPeer *peer, const ENetProtocol *command, ENetPacket *packet, enet_uint32 offset, enet_uint16 length) {
-        ENetOutgoingCommand *outgoingCommand = (ENetOutgoingCommand *)enet_malloc(sizeof(ENetOutgoingCommand));
-
-        if (outgoingCommand == NULL) {
-            return NULL;
-        }
-
-        outgoingCommand->command        = *command;
-        outgoingCommand->fragmentOffset = offset;
-        outgoingCommand->fragmentLength = length;
-        outgoingCommand->packet         = packet;
-
-        if (packet != NULL) {
-            ++packet->referenceCount;
-        }
-
-        enet_peer_setup_outgoing_command(peer, outgoingCommand);
-
-        return outgoingCommand;
-    }
-
-    void enet_peer_dispatch_incoming_unreliable_commands(ENetPeer *peer, ENetChannel *channel) {
-        ENetListIterator droppedCommand, startCommand, currentCommand;
-
-        for (droppedCommand = startCommand = currentCommand = enet_list_begin(&channel->incomingUnreliableCommands);
-            currentCommand != enet_list_end(&channel->incomingUnreliableCommands);
-            currentCommand = enet_list_next(currentCommand)
-        ) {
-            ENetIncomingCommand *incomingCommand = (ENetIncomingCommand *)currentCommand;
-
-            if ((incomingCommand->command.header.command & ENET_PROTOCOL_COMMAND_MASK) == ENET_PROTOCOL_COMMAND_SEND_UNSEQUENCED) {
-                continue;
-            }
-
-            if (incomingCommand->reliableSequenceNumber == channel->incomingReliableSequenceNumber) {
-                if (incomingCommand->fragmentsRemaining <= 0) {
-                    channel->incomingUnreliableSequenceNumber = incomingCommand->unreliableSequenceNumber;
-                    continue;
-                }
-
-                if (startCommand != currentCommand) {
-                    enet_list_move(enet_list_end(&peer->dispatchedCommands), startCommand, enet_list_previous(currentCommand));
-
-                    if (!peer->needsDispatch) {
-                        enet_list_insert(enet_list_end(&peer->host->dispatchQueue), &peer->dispatchList);
-                        peer->needsDispatch = 1;
-                    }
-
-                    droppedCommand = currentCommand;
-                } else if (droppedCommand != currentCommand) {
-                    droppedCommand = enet_list_previous(currentCommand);
-                }
-            } else {
-                enet_uint16 reliableWindow = incomingCommand->reliableSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE;
-                enet_uint16 currentWindow  = channel->incomingReliableSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE;
-
-                if (incomingCommand->reliableSequenceNumber < channel->incomingReliableSequenceNumber) {
-                    reliableWindow += ENET_PEER_RELIABLE_WINDOWS;
-                }
-
-                if (reliableWindow >= currentWindow && reliableWindow < currentWindow + ENET_PEER_FREE_RELIABLE_WINDOWS - 1) {
-                    break;
-                }
-
-                droppedCommand = enet_list_next(currentCommand);
-
-                if (startCommand != currentCommand) {
-                    enet_list_move(enet_list_end(&peer->dispatchedCommands), startCommand, enet_list_previous(currentCommand));
-
-                    if (!peer->needsDispatch) {
-                        enet_list_insert(enet_list_end(&peer->host->dispatchQueue), &peer->dispatchList);
-                        peer->needsDispatch = 1;
-                    }
-                }
-            }
-
-            startCommand = enet_list_next(currentCommand);
-        }
-
-        if (startCommand != currentCommand) {
-            enet_list_move(enet_list_end(&peer->dispatchedCommands), startCommand, enet_list_previous(currentCommand));
-
-            if (!peer->needsDispatch) {
-                enet_list_insert(enet_list_end(&peer->host->dispatchQueue), &peer->dispatchList);
-                peer->needsDispatch = 1;
-            }
-
-            droppedCommand = currentCommand;
-        }
-
-        enet_peer_remove_incoming_commands(&channel->incomingUnreliableCommands,enet_list_begin(&channel->incomingUnreliableCommands), droppedCommand);
-    }
-
-    void enet_peer_dispatch_incoming_reliable_commands(ENetPeer *peer, ENetChannel *channel) {
-        ENetListIterator currentCommand;
-
-        for (currentCommand = enet_list_begin(&channel->incomingReliableCommands);
-            currentCommand != enet_list_end(&channel->incomingReliableCommands);
-            currentCommand = enet_list_next(currentCommand)
-        ) {
-            ENetIncomingCommand *incomingCommand = (ENetIncomingCommand *)currentCommand;
-
-            if (incomingCommand->fragmentsRemaining > 0 || incomingCommand->reliableSequenceNumber != (enet_uint16) (channel->incomingReliableSequenceNumber + 1)) {
-                break;
-            }
-
-            channel->incomingReliableSequenceNumber = incomingCommand->reliableSequenceNumber;
-
-            if (incomingCommand->fragmentCount > 0) {
-                channel->incomingReliableSequenceNumber += incomingCommand->fragmentCount - 1;
-            }
-        }
-
-        if (currentCommand == enet_list_begin(&channel->incomingReliableCommands)) {
-            return;
-        }
-
-        channel->incomingUnreliableSequenceNumber = 0;
-        enet_list_move(enet_list_end(&peer->dispatchedCommands), enet_list_begin(&channel->incomingReliableCommands), enet_list_previous(currentCommand));
-
-        if (!peer->needsDispatch) {
-            enet_list_insert(enet_list_end(&peer->host->dispatchQueue), &peer->dispatchList);
-            peer->needsDispatch = 1;
-        }
-
-        if (!enet_list_empty(&channel->incomingUnreliableCommands)) {
-            enet_peer_dispatch_incoming_unreliable_commands(peer, channel);
-        }
-    }
-
-    ENetIncomingCommand * enet_peer_queue_incoming_command(ENetPeer *peer, const ENetProtocol *command, const void *data, size_t dataLength, enet_uint32 flags, enet_uint32 fragmentCount) {
-        static ENetIncomingCommand dummyCommand;
-
-        ENetChannel *channel = &peer->channels[command->header.channelID];
-        enet_uint32 unreliableSequenceNumber = 0, reliableSequenceNumber = 0;
-        enet_uint16 reliableWindow, currentWindow;
-        ENetIncomingCommand *incomingCommand;
-        ENetListIterator currentCommand;
-        ENetPacket *packet = NULL;
-
-        if (peer->state == ENET_PEER_STATE_DISCONNECT_LATER) {
-            goto discardCommand;
-        }
-
-        if ((command->header.command & ENET_PROTOCOL_COMMAND_MASK) != ENET_PROTOCOL_COMMAND_SEND_UNSEQUENCED) {
-            reliableSequenceNumber = command->header.reliableSequenceNumber;
-            reliableWindow         = reliableSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE;
-            currentWindow = channel->incomingReliableSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE;
-
-            if (reliableSequenceNumber < channel->incomingReliableSequenceNumber) {
-                reliableWindow += ENET_PEER_RELIABLE_WINDOWS;
-            }
-
-            if (reliableWindow < currentWindow || reliableWindow >= currentWindow + ENET_PEER_FREE_RELIABLE_WINDOWS - 1) {
-                goto discardCommand;
-            }
-        }
-
-        switch (command->header.command & ENET_PROTOCOL_COMMAND_MASK) {
-            case ENET_PROTOCOL_COMMAND_SEND_FRAGMENT:
-            case ENET_PROTOCOL_COMMAND_SEND_RELIABLE:
-                if (reliableSequenceNumber == channel->incomingReliableSequenceNumber) {
-                    goto discardCommand;
-                }
-
-                for (currentCommand = enet_list_previous(enet_list_end(&channel->incomingReliableCommands));
-                    currentCommand != enet_list_end(&channel->incomingReliableCommands);
-                    currentCommand = enet_list_previous(currentCommand)
-                ) {
-                    incomingCommand = (ENetIncomingCommand *)currentCommand;
-
-                    if (reliableSequenceNumber >= channel->incomingReliableSequenceNumber) {
-                        if (incomingCommand->reliableSequenceNumber < channel->incomingReliableSequenceNumber) {
-                            continue;
-                        }
-                    } else if (incomingCommand->reliableSequenceNumber >= channel->incomingReliableSequenceNumber) {
-                        break;
-                    }
-
-                    if (incomingCommand->reliableSequenceNumber <= reliableSequenceNumber) {
-                        if (incomingCommand->reliableSequenceNumber < reliableSequenceNumber) {
-                            break;
-                        }
-
-                        goto discardCommand;
-                    }
-                }
-                break;
-
-            case ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE:
-            case ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE_FRAGMENT:
-                unreliableSequenceNumber = ENET_NET_TO_HOST_16(command->sendUnreliable.unreliableSequenceNumber);
-
-                if (reliableSequenceNumber == channel->incomingReliableSequenceNumber && unreliableSequenceNumber <= channel->incomingUnreliableSequenceNumber) {
-                    goto discardCommand;
-                }
-
-                for (currentCommand = enet_list_previous(enet_list_end(&channel->incomingUnreliableCommands));
-                    currentCommand != enet_list_end(&channel->incomingUnreliableCommands);
-                    currentCommand = enet_list_previous(currentCommand)
-                ) {
-                    incomingCommand = (ENetIncomingCommand *)currentCommand;
-
-                    if ((command->header.command & ENET_PROTOCOL_COMMAND_MASK) == ENET_PROTOCOL_COMMAND_SEND_UNSEQUENCED) {
-                        continue;
-                    }
-
-                    if (reliableSequenceNumber >= channel->incomingReliableSequenceNumber) {
-                        if (incomingCommand->reliableSequenceNumber < channel->incomingReliableSequenceNumber) {
-                            continue;
-                        }
-                    } else if (incomingCommand->reliableSequenceNumber >= channel->incomingReliableSequenceNumber) {
-                        break;
-                    }
-
-                    if (incomingCommand->reliableSequenceNumber < reliableSequenceNumber) {
-                        break;
-                    }
-
-                    if (incomingCommand->reliableSequenceNumber > reliableSequenceNumber) {
-                        continue;
-                    }
-
-                    if (incomingCommand->unreliableSequenceNumber <= unreliableSequenceNumber) {
-                        if (incomingCommand->unreliableSequenceNumber < unreliableSequenceNumber) {
-                            break;
-                        }
-
-                        goto discardCommand;
-                    }
-                }
-                break;
-
-            case ENET_PROTOCOL_COMMAND_SEND_UNSEQUENCED:
-                currentCommand = enet_list_end(&channel->incomingUnreliableCommands);
-                break;
-
-            default:
-                goto discardCommand;
-        }
-
-        if (peer->totalWaitingData >= peer->host->maximumWaitingData) {
-            goto notifyError;
-        }
-
-        packet = enet_packet_create(data, dataLength, flags);
-
-        if (packet == NULL) {
-            goto notifyError;
-        }
-
-        incomingCommand = (ENetIncomingCommand *)enet_malloc(sizeof(ENetIncomingCommand));
-
-        if (incomingCommand == NULL) {
-            goto notifyError;
-        }
-
-        incomingCommand->reliableSequenceNumber     = command->header.reliableSequenceNumber;
-        incomingCommand->unreliableSequenceNumber   = unreliableSequenceNumber & 0xFFFF;
-        incomingCommand->command                    = *command;
-        incomingCommand->fragmentCount              = fragmentCount;
-        incomingCommand->fragmentsRemaining         = fragmentCount;
-        incomingCommand->packet                     = packet;
-        incomingCommand->fragments                  = NULL;
-
-        if (fragmentCount > 0) {
-            if (fragmentCount <= ENET_PROTOCOL_MAXIMUM_FRAGMENT_COUNT) {
-                incomingCommand->fragments = (enet_uint32 *)enet_malloc((fragmentCount + 31) / 32 * sizeof(enet_uint32));
-            }
-
-            if (incomingCommand->fragments == NULL) {
-                enet_free(incomingCommand);
-
-                goto notifyError;
-            }
-
-            memset(incomingCommand->fragments, 0, (fragmentCount + 31) / 32 * sizeof(enet_uint32));
-        }
-
-        if (packet != NULL) {
-            ++packet->referenceCount;
-            peer->totalWaitingData += packet->dataLength;
-        }
-
-        enet_list_insert(enet_list_next(currentCommand), incomingCommand);
-
-        switch (command->header.command & ENET_PROTOCOL_COMMAND_MASK) {
-            case ENET_PROTOCOL_COMMAND_SEND_FRAGMENT:
-            case ENET_PROTOCOL_COMMAND_SEND_RELIABLE:
-                enet_peer_dispatch_incoming_reliable_commands(peer, channel);
-                break;
-
-            default:
-                enet_peer_dispatch_incoming_unreliable_commands(peer, channel);
-                break;
-        }
-
-        return incomingCommand;
-
-    discardCommand:
-        if (fragmentCount > 0) {
-            goto notifyError;
-        }
-
-        if (packet != NULL && packet->referenceCount == 0) {
-            enet_packet_destroy(packet);
-        }
-
-        return &dummyCommand;
-
-    notifyError:
-        if (packet != NULL && packet->referenceCount == 0) {
-            enet_packet_destroy(packet);
-        }
-
-        return NULL;
-    }
-
-// =======================================================================//
-// !
-// ! Host
-// !
-// =======================================================================//
-
-    ENetHost * enet_host_create(const ENetAddress *address, size_t peerCount, size_t channelLimit, enet_uint32 incomingBandwidth, enet_uint32 outgoingBandwidth) {
-        ENetHost *host;
-        ENetPeer *currentPeer;
-
-        if (peerCount > ENET_PROTOCOL_MAXIMUM_PEER_ID) {
-            return NULL;
-        }
-
-        host = (ENetHost *)enet_malloc(sizeof(ENetHost));
-
-        if (host == NULL) {
-            return NULL;
-        }
-
-        memset(host, 0, sizeof(ENetHost));
-
-        host->peers = (ENetPeer *)enet_malloc(peerCount * sizeof(ENetPeer));
-
-        if (host->peers == NULL) {
-            enet_free(host);
-
-            return NULL;
-        }
-
-        memset(host->peers, 0, peerCount * sizeof(ENetPeer));
-
-        host->socket = enet_socket_create(ENET_SOCKET_TYPE_DATAGRAM);
-
-        if (host->socket != ENET_SOCKET_NULL) {
-            enet_socket_set_option (host->socket, ENET_SOCKOPT_IPV6_V6ONLY, 0);
-        }
-
-        if (host->socket == ENET_SOCKET_NULL || (address != NULL && enet_socket_bind(host->socket, address) < 0)) {
-            if (host->socket != ENET_SOCKET_NULL) {
-                enet_socket_destroy(host->socket);
-            }
-
-            enet_free(host->peers);
-            enet_free(host);
-
-            return NULL;
-        }
-
-        enet_socket_set_option(host->socket, ENET_SOCKOPT_NONBLOCK, 1);
-        enet_socket_set_option(host->socket, ENET_SOCKOPT_BROADCAST, 1);
-        enet_socket_set_option(host->socket, ENET_SOCKOPT_RCVBUF, ENET_HOST_RECEIVE_BUFFER_SIZE);
-        enet_socket_set_option(host->socket, ENET_SOCKOPT_SNDBUF, ENET_HOST_SEND_BUFFER_SIZE);
-        enet_socket_set_option(host->socket, ENET_SOCKOPT_IPV6_V6ONLY, 0);
-
-        if (address != NULL && enet_socket_get_address(host->socket, &host->address) < 0) {
-            host->address = *address;
-        }
-
-        if (!channelLimit || channelLimit > ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT) {
-            channelLimit = ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT;
-        } else if (channelLimit < ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT) {
-            channelLimit = ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT;
-        }
-
-        host->randomSeed                    = (enet_uint32) (size_t) host;
-        host->randomSeed                    += enet_host_random_seed();
-        host->randomSeed                    = (host->randomSeed << 16) | (host->randomSeed >> 16);
-        host->channelLimit                  = channelLimit;
-        host->incomingBandwidth             = incomingBandwidth;
-        host->outgoingBandwidth             = outgoingBandwidth;
-        host->bandwidthThrottleEpoch        = 0;
-        host->recalculateBandwidthLimits    = 0;
-        host->mtu                           = ENET_HOST_DEFAULT_MTU;
-        host->peerCount                     = peerCount;
-        host->commandCount                  = 0;
-        host->bufferCount                   = 0;
-        host->checksum                      = NULL;
-        host->receivedAddress.host          = ENET_HOST_ANY;
-        host->receivedAddress.port          = 0;
-        host->receivedData                  = NULL;
-        host->receivedDataLength            = 0;
-        host->totalSentData                 = 0;
-        host->totalSentPackets              = 0;
-        host->totalReceivedData             = 0;
-        host->totalReceivedPackets          = 0;
-        host->connectedPeers                = 0;
-        host->bandwidthLimitedPeers         = 0;
-        host->duplicatePeers                = ENET_PROTOCOL_MAXIMUM_PEER_ID;
-        host->maximumPacketSize             = ENET_HOST_DEFAULT_MAXIMUM_PACKET_SIZE;
-        host->maximumWaitingData            = ENET_HOST_DEFAULT_MAXIMUM_WAITING_DATA;
-        host->intercept                     = NULL;
-
-        enet_list_clear(&host->dispatchQueue);
-
-        for (currentPeer = host->peers; currentPeer < &host->peers[host->peerCount]; ++currentPeer) {
-            currentPeer->host = host;
-            currentPeer->incomingPeerID    = currentPeer - host->peers;
-            currentPeer->outgoingSessionID = currentPeer->incomingSessionID = 0xFF;
-            currentPeer->data = NULL;
-
-            enet_list_clear(&currentPeer->acknowledgements);
-            enet_list_clear(&currentPeer->sentReliableCommands);
-            enet_list_clear(&currentPeer->sentUnreliableCommands);
-            enet_list_clear(&currentPeer->outgoingReliableCommands);
-            enet_list_clear(&currentPeer->outgoingUnreliableCommands);
-            enet_list_clear(&currentPeer->dispatchedCommands);
-
-            enet_peer_reset(currentPeer);
-        }
-
-        return host;
-    }
-
-    void enet_host_destroy(ENetHost *host) {
-        ENetPeer *currentPeer;
-
-        if (host == NULL) {
-            return;
-        }
-
-        enet_socket_destroy(host->socket);
-
-        for (currentPeer = host->peers; currentPeer < &host->peers[host->peerCount]; ++currentPeer) {
-            enet_peer_reset(currentPeer);
-        }
-
-        enet_free(host->peers);
-        enet_free(host);
-    }
-
-    ENetPeer * enet_host_connect(ENetHost *host, const ENetAddress *address, size_t channelCount, enet_uint32 data) {
-        ENetPeer *currentPeer;
-        ENetChannel *channel;
-        ENetProtocol command;
-
-        if (channelCount < ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT) {
-            channelCount = ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT;
-        } else if (channelCount > ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT) {
-            channelCount = ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT;
-        }
-
-        for (currentPeer = host->peers; currentPeer < &host->peers[host->peerCount]; ++currentPeer) {
-            if (currentPeer->state == ENET_PEER_STATE_DISCONNECTED) {
-                break;
-            }
-        }
-
-        if (currentPeer >= &host->peers[host->peerCount]) {
-            return NULL;
-        }
-
-        currentPeer->channels = (ENetChannel *)enet_malloc(channelCount * sizeof(ENetChannel));
-
-        if (currentPeer->channels == NULL) {
-            return NULL;
-        }
-
-        currentPeer->channelCount = channelCount;
-        currentPeer->state        = ENET_PEER_STATE_CONNECTING;
-        currentPeer->address      = *address;
-        currentPeer->connectID    = ++host->randomSeed;
-
-        if (host->outgoingBandwidth == 0) {
-            currentPeer->windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
-        } else {
-            currentPeer->windowSize = (host->outgoingBandwidth / ENET_PEER_WINDOW_SIZE_SCALE) * ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
-        }
-
-        if (currentPeer->windowSize < ENET_PROTOCOL_MINIMUM_WINDOW_SIZE) {
-            currentPeer->windowSize = ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
-        } else if (currentPeer->windowSize > ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE) {
-            currentPeer->windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
-        }
-
-        for (channel = currentPeer->channels; channel < &currentPeer->channels[channelCount]; ++channel) {
-            channel->outgoingReliableSequenceNumber   = 0;
-            channel->outgoingUnreliableSequenceNumber = 0;
-            channel->incomingReliableSequenceNumber   = 0;
-            channel->incomingUnreliableSequenceNumber = 0;
-
-            enet_list_clear(&channel->incomingReliableCommands);
-            enet_list_clear(&channel->incomingUnreliableCommands);
-
-            channel->usedReliableWindows = 0;
-            memset(channel->reliableWindows, 0, sizeof(channel->reliableWindows));
-        }
-
-        command.header.command                     = ENET_PROTOCOL_COMMAND_CONNECT | ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE;
-        command.header.channelID                   = 0xFF;
-        command.connect.outgoingPeerID             = ENET_HOST_TO_NET_16(currentPeer->incomingPeerID);
-        command.connect.incomingSessionID          = currentPeer->incomingSessionID;
-        command.connect.outgoingSessionID          = currentPeer->outgoingSessionID;
-        command.connect.mtu                        = ENET_HOST_TO_NET_32(currentPeer->mtu);
-        command.connect.windowSize                 = ENET_HOST_TO_NET_32(currentPeer->windowSize);
-        command.connect.channelCount               = ENET_HOST_TO_NET_32(channelCount);
-        command.connect.incomingBandwidth          = ENET_HOST_TO_NET_32(host->incomingBandwidth);
-        command.connect.outgoingBandwidth          = ENET_HOST_TO_NET_32(host->outgoingBandwidth);
-        command.connect.packetThrottleInterval     = ENET_HOST_TO_NET_32(currentPeer->packetThrottleInterval);
-        command.connect.packetThrottleAcceleration = ENET_HOST_TO_NET_32(currentPeer->packetThrottleAcceleration);
-        command.connect.packetThrottleDeceleration = ENET_HOST_TO_NET_32(currentPeer->packetThrottleDeceleration);
-        command.connect.connectID                  = currentPeer->connectID;
-        command.connect.data                       = ENET_HOST_TO_NET_32(data);
-
-        enet_peer_queue_outgoing_command(currentPeer, &command, NULL, 0, 0);
-
-        return currentPeer;
-    }
-
-    void enet_host_broadcast(ENetHost *host, enet_uint8 channelID, ENetPacket *packet) {
-        ENetPeer *currentPeer;
-
-        for (currentPeer = host->peers; currentPeer < &host->peers[host->peerCount]; ++currentPeer) {
-            if (currentPeer->state != ENET_PEER_STATE_CONNECTED) {
-                continue;
-            }
-
-            enet_peer_send(currentPeer, channelID, packet);
-        }
-
-        if (packet->referenceCount == 0) {
-            enet_packet_destroy(packet);
-        }
-    }
-
-    void enet_host_channel_limit(ENetHost *host, size_t channelLimit) {
-        if (!channelLimit || channelLimit > ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT) {
-            channelLimit = ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT;
-        } else if (channelLimit < ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT) {
-            channelLimit = ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT;
-        }
-
-        host->channelLimit = channelLimit;
-    }
-
-    void enet_host_bandwidth_limit(ENetHost *host, enet_uint32 incomingBandwidth, enet_uint32 outgoingBandwidth) {
-        host->incomingBandwidth = incomingBandwidth;
-        host->outgoingBandwidth = outgoingBandwidth;
-        host->recalculateBandwidthLimits = 1;
-    }
-
-    void enet_host_bandwidth_throttle(ENetHost *host) {
-        enet_uint32 timeCurrent       = enet_time_get();
-        enet_uint32 elapsedTime       = timeCurrent - host->bandwidthThrottleEpoch;
-        enet_uint32 peersRemaining    = (enet_uint32) host->connectedPeers;
-        enet_uint32 dataTotal         = ~0;
-        enet_uint32 bandwidth         = ~0;
-        enet_uint32 throttle          = 0;
-        enet_uint32 bandwidthLimit    = 0;
-
-        int needsAdjustment = host->bandwidthLimitedPeers > 0 ? 1 : 0;
-        ENetPeer *peer;
-        ENetProtocol command;
-
-        if (elapsedTime < ENET_HOST_BANDWIDTH_THROTTLE_INTERVAL) {
-            return;
-        }
-
-        if (host->outgoingBandwidth == 0 && host->incomingBandwidth == 0) {
-            return;
-        }
-
-        host->bandwidthThrottleEpoch = timeCurrent;
-
-        if (peersRemaining == 0) {
-            return;
-        }
-
-        if (host->outgoingBandwidth != 0) {
-            dataTotal = 0;
-            bandwidth = (host->outgoingBandwidth * elapsedTime) / 1000;
-
-            for (peer = host->peers; peer < &host->peers[host->peerCount]; ++peer) {
-                if (peer->state != ENET_PEER_STATE_CONNECTED && peer->state != ENET_PEER_STATE_DISCONNECT_LATER) {
-                    continue;
-                }
-
-                dataTotal += peer->outgoingDataTotal;
-            }
-        }
-
-        while (peersRemaining > 0 && needsAdjustment != 0) {
-            needsAdjustment = 0;
-
-            if (dataTotal <= bandwidth) {
-                throttle = ENET_PEER_PACKET_THROTTLE_SCALE;
-            } else {
-                throttle = (bandwidth * ENET_PEER_PACKET_THROTTLE_SCALE) / dataTotal;
-            }
-
-            for (peer = host->peers; peer < &host->peers[host->peerCount]; ++peer) {
-                enet_uint32 peerBandwidth;
-
-                if ((peer->state != ENET_PEER_STATE_CONNECTED && peer->state != ENET_PEER_STATE_DISCONNECT_LATER) ||
-                    peer->incomingBandwidth == 0 ||
-                    peer->outgoingBandwidthThrottleEpoch == timeCurrent
-                ) {
-                    continue;
-                }
-
-                peerBandwidth = (peer->incomingBandwidth * elapsedTime) / 1000;
-
-                if ((throttle * peer->outgoingDataTotal) / ENET_PEER_PACKET_THROTTLE_SCALE <= peerBandwidth) {
-                    continue;
-                }
-
-                peer->packetThrottleLimit = (peerBandwidth * ENET_PEER_PACKET_THROTTLE_SCALE) / peer->outgoingDataTotal;
-
-                if (peer->packetThrottleLimit == 0) {
-                    peer->packetThrottleLimit = 1;
-                }
-
-                if (peer->packetThrottle > peer->packetThrottleLimit) {
-                    peer->packetThrottle = peer->packetThrottleLimit;
-                }
-
-                peer->outgoingBandwidthThrottleEpoch = timeCurrent;
-
-                peer->incomingDataTotal = 0;
-                peer->outgoingDataTotal = 0;
-
-                needsAdjustment = 1;
-                --peersRemaining;
-                bandwidth -= peerBandwidth;
-                dataTotal -= peerBandwidth;
-            }
-        }
-
-        if (peersRemaining > 0) {
-            if (dataTotal <= bandwidth) {
-                throttle = ENET_PEER_PACKET_THROTTLE_SCALE;
-            } else {
-                throttle = (bandwidth * ENET_PEER_PACKET_THROTTLE_SCALE) / dataTotal;
-            }
-
-            for (peer = host->peers;
-              peer < &host->peers[host->peerCount];
-              ++peer)
-            {
-                if ((peer->state != ENET_PEER_STATE_CONNECTED && peer->state != ENET_PEER_STATE_DISCONNECT_LATER) || peer->outgoingBandwidthThrottleEpoch == timeCurrent) {
-                    continue;
-                }
-
-                peer->packetThrottleLimit = throttle;
-
-                if (peer->packetThrottle > peer->packetThrottleLimit) {
-                    peer->packetThrottle = peer->packetThrottleLimit;
-                }
-
-                peer->incomingDataTotal = 0;
-                peer->outgoingDataTotal = 0;
-            }
-        }
-
-        if (host->recalculateBandwidthLimits) {
-            host->recalculateBandwidthLimits = 0;
-
-            peersRemaining  = (enet_uint32) host->connectedPeers;
-            bandwidth       = host->incomingBandwidth;
-            needsAdjustment = 1;
-
-            if (bandwidth == 0) {
-                bandwidthLimit = 0;
-            } else {
-                while (peersRemaining > 0 && needsAdjustment != 0) {
-                    needsAdjustment = 0;
-                    bandwidthLimit  = bandwidth / peersRemaining;
-
-                    for (peer = host->peers; peer < &host->peers[host->peerCount]; ++peer) {
-                        if ((peer->state != ENET_PEER_STATE_CONNECTED && peer->state != ENET_PEER_STATE_DISCONNECT_LATER) ||
-                            peer->incomingBandwidthThrottleEpoch == timeCurrent
-                        ) {
-                            continue;
-                        }
-
-                        if (peer->outgoingBandwidth > 0 && peer->outgoingBandwidth >= bandwidthLimit) {
-                            continue;
-                        }
-
-                        peer->incomingBandwidthThrottleEpoch = timeCurrent;
-
-                        needsAdjustment = 1;
-                        --peersRemaining;
-                        bandwidth -= peer->outgoingBandwidth;
-                    }
-                }
-            }
-
-            for (peer = host->peers; peer < &host->peers[host->peerCount]; ++peer) {
-                if (peer->state != ENET_PEER_STATE_CONNECTED && peer->state != ENET_PEER_STATE_DISCONNECT_LATER) {
-                    continue;
-                }
-
-                command.header.command   = ENET_PROTOCOL_COMMAND_BANDWIDTH_LIMIT | ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE;
-                command.header.channelID = 0xFF;
-                command.bandwidthLimit.outgoingBandwidth = ENET_HOST_TO_NET_32(host->outgoingBandwidth);
-
-                if (peer->incomingBandwidthThrottleEpoch == timeCurrent) {
-                    command.bandwidthLimit.incomingBandwidth = ENET_HOST_TO_NET_32(peer->outgoingBandwidth);
-                } else {
-                    command.bandwidthLimit.incomingBandwidth = ENET_HOST_TO_NET_32(bandwidthLimit);
-                }
-
-                enet_peer_queue_outgoing_command(peer, &command, NULL, 0, 0);
-            }
-        }
-    }
-
-// =======================================================================//
-// !
-// ! Time
-// !
-// =======================================================================//
-
-    #ifdef _WIN32
-        static LARGE_INTEGER getFILETIMEoffset() {
-            SYSTEMTIME s;
-            FILETIME f;
-            LARGE_INTEGER t;
-
-            s.wYear = 1970;
-            s.wMonth = 1;
-            s.wDay = 1;
-            s.wHour = 0;
-            s.wMinute = 0;
-            s.wSecond = 0;
-            s.wMilliseconds = 0;
-            SystemTimeToFileTime(&s, &f);
-            t.QuadPart = f.dwHighDateTime;
-            t.QuadPart <<= 32;
-            t.QuadPart |= f.dwLowDateTime;
-            return (t);
-        }
-
-        int clock_gettime(int X, struct timespec *tv) {
-            LARGE_INTEGER t;
-            FILETIME f;
-            double microseconds;
-            static LARGE_INTEGER offset;
-            static double frequencyToMicroseconds;
-            static int initialized = 0;
-            static BOOL usePerformanceCounter = 0;
-
-            if (!initialized) {
-                LARGE_INTEGER performanceFrequency;
-                initialized = 1;
-                usePerformanceCounter = QueryPerformanceFrequency(&performanceFrequency);
-                if (usePerformanceCounter) {
-                    QueryPerformanceCounter(&offset);
-                    frequencyToMicroseconds = (double)performanceFrequency.QuadPart / 1000000.;
-                } else {
-                    offset = getFILETIMEoffset();
-                    frequencyToMicroseconds = 10.;
-                }
-            }
-
-            if (usePerformanceCounter) {
-                QueryPerformanceCounter(&t);
-            } else {
-                GetSystemTimeAsFileTime(&f);
-                t.QuadPart = f.dwHighDateTime;
-                t.QuadPart <<= 32;
-                t.QuadPart |= f.dwLowDateTime;
-            }
-
-            t.QuadPart -= offset.QuadPart;
-            microseconds = (double)t.QuadPart / frequencyToMicroseconds;
-            t.QuadPart = (LONGLONG)microseconds;
-            tv->tv_sec = (long) (t.QuadPart / 1000000);
-            tv->tv_nsec = t.QuadPart % 1000000 * 1000;
-
-            return (0);
-        }
-    #elif __APPLE__ && __MAC_OS_X_VERSION_MIN_REQUIRED < 101200
-        #define CLOCK_MONOTONIC 0
-
-        int clock_gettime(int X, struct timespec *ts) {
-            clock_serv_t cclock;
-            mach_timespec_t mts;
-
-            host_get_clock_service(mach_host_self(), SYSTEM_CLOCK, &cclock);
-            clock_get_time(cclock, &mts);
-            mach_port_deallocate(mach_task_self(), cclock);
-
-            ts->tv_sec = mts.tv_sec;
-            ts->tv_nsec = mts.tv_nsec;
-
-            return 0;
-        }
-    #endif
-
-    enet_uint32 enet_time_get() {
-        static uint64_t start_time_ns = 0;
-
-        struct timespec ts;
-    #if defined(CLOCK_MONOTONIC_RAW)
-        clock_gettime(CLOCK_MONOTONIC_RAW, &ts);
-    #else
-        clock_gettime(CLOCK_MONOTONIC, &ts);
-    #endif
-
-        static const uint64_t ns_in_s = 1000 * 1000 * 1000;
-        static const uint64_t ns_in_ms = 1000 * 1000;
-
-        uint64_t current_time_ns = ts.tv_nsec + (uint64_t)ts.tv_sec * ns_in_s;
-        uint64_t offset_ns = ENET_ATOMIC_READ(&start_time_ns);
-
-        if (offset_ns == 0) {
-            uint64_t want_value = current_time_ns - 1 * ns_in_ms;
-            uint64_t old_value = ENET_ATOMIC_CAS(&start_time_ns, 0, want_value);
-
-            offset_ns = old_value == 0 ? want_value : old_value;
-        }
-
-        uint64_t result_in_ns = current_time_ns - offset_ns;
-
-        return (enet_uint32) (result_in_ns / ns_in_ms);
-    }
-
-// =======================================================================//
-// !
-// ! Extended functionality
-// !
-// =======================================================================//
-
-    void * enet_packet_get_data(ENetPacket *packet) {
-        return (void *)packet->data;
-    }
-
-    int enet_packet_get_length(ENetPacket *packet) {
-        return packet->dataLength;
-    }
-
-    void enet_packet_set_free_callback(ENetPacket *packet, const void *callback) {
-        packet->freeCallback = (ENetPacketFreeCallback)callback;
-    }
-
-    enet_uint32 enet_host_get_peers_count(ENetHost *host) {
-        return host->connectedPeers;
-    }
-
-    enet_uint32 enet_host_get_packets_sent(ENetHost *host) {
-        return host->totalSentPackets;
-    }
-
-    enet_uint32 enet_host_get_packets_received(ENetHost *host) {
-        return host->totalReceivedPackets;
-    }
-
-    enet_uint32 enet_host_get_bytes_sent(ENetHost *host) {
-        return host->totalSentData;
-    }
-
-    enet_uint32 enet_host_get_bytes_received(ENetHost *host) {
-        return host->totalReceivedData;
-    }
-
-    enet_uint32 enet_peer_get_id(ENetPeer *peer) {
-        return peer->connectID;
-    }
-
-    int enet_peer_get_ip(ENetPeer *peer, char *ip, size_t ipLength) {
-        return enet_address_get_host_ip(&peer->address, ip, ipLength);
-    }
-
-    enet_uint16 enet_peer_get_port(ENetPeer *peer) {
-        return peer->address.port;
-    }
-
-    ENetPeerState enet_peer_get_state(ENetPeer *peer) {
-        return peer->state;
-    }
-
-    enet_uint32 enet_peer_get_rtt(ENetPeer *peer) {
-        return peer->roundTripTime;
-    }
-
-    enet_uint64 enet_peer_get_packets_sent(ENetPeer *peer) {
-        return peer->totalPacketsSent;
-    }
-
-    enet_uint32 enet_peer_get_packets_lost(ENetPeer *peer) {
-        return peer->totalPacketsLost;
-    }
-
-    enet_uint64 enet_peer_get_bytes_sent(ENetPeer *peer) {
-        return peer->totalDataSent;
-    }
-
-    enet_uint64 enet_peer_get_bytes_received(ENetPeer *peer) {
-        return peer->totalDataReceived;
-    }
- 
-    void * enet_peer_get_data(ENetPeer *peer) {
-        return (void *)peer->data;
-    }
-
-    void enet_peer_set_data(ENetPeer *peer, const void *data) {
-        peer->data = (enet_uint32 *)data;
-    }
-
-// =======================================================================//
-// !
-// ! Platform Specific (Unix)
-// !
-// =======================================================================//
-
-    #ifndef _WIN32
-        int enet_initialize(void) {
-            return 0;
-        }
-
-        void enet_deinitialize(void);
-
-        enet_uint64 enet_host_random_seed(void) {
-            return (enet_uint64) time(NULL);
-        }
-
-        int enet_address_set_host_ip(ENetAddress *address, const char *name) {
-            if (!inet_pton(AF_INET6, name, &address->host)) {
-                return -1;
-            }
-
-            return 0;
-        }
-
-        int enet_address_set_host(ENetAddress *address, const char *name) {
-            struct addrinfo hints, *resultList = NULL, *result = NULL;
-
-            memset(&hints, 0, sizeof(hints));
-            hints.ai_family = AF_UNSPEC;
-
-            if (getaddrinfo(name, NULL, &hints, &resultList) != 0) {
-                return -1;
-            }
-
-            for (result = resultList; result != NULL; result = result->ai_next) {
-                if (result->ai_addr != NULL && result->ai_addrlen >= sizeof(struct sockaddr_in)) {
-                    if (result->ai_family == AF_INET) {
-                        struct sockaddr_in * sin = (struct sockaddr_in *)result->ai_addr;
-
-                        ((uint32_t *)&address->host.s6_addr)[0] = 0;
-                        ((uint32_t *)&address->host.s6_addr)[1] = 0;
-                        ((uint32_t *)&address->host.s6_addr)[2] = htonl(0xffff);
-                        ((uint32_t *)&address->host.s6_addr)[3] = sin->sin_addr.s_addr;
-
-                        freeaddrinfo(resultList);
-
-                        return 0;
-                    } else if (result->ai_family == AF_INET6) {
-                        struct sockaddr_in6 * sin = (struct sockaddr_in6 *)result->ai_addr;
-
-                        address->host = sin->sin6_addr;
-                        address->sin6_scope_id = sin->sin6_scope_id;
-
-                        freeaddrinfo(resultList);
-
-                        return 0;
-                    }
-                }
-            }
-
-            if (resultList != NULL) {
-                freeaddrinfo(resultList);
-            }
-
-            return enet_address_set_host_ip(address, name);
-        }
-
-        int enet_address_get_host_ip(const ENetAddress *address, char *name, size_t nameLength) {
-            if (inet_ntop(AF_INET6, &address->host, name, nameLength) == NULL) {
-                return -1;
-            }
-
-            return 0;
-        }
-
-        int enet_address_get_host(const ENetAddress *address, char *name, size_t nameLength) {
-            struct sockaddr_in6 sin;
-            int err;
-
-            memset(&sin, 0, sizeof(struct sockaddr_in6));
-
-            sin.sin6_family = AF_INET6;
-            sin.sin6_port = ENET_HOST_TO_NET_16 (address->port);
-            sin.sin6_addr = address->host;
-            sin.sin6_scope_id = address->sin6_scope_id;
-
-            err = getnameinfo((struct sockaddr *)&sin, sizeof(sin), name, nameLength, NULL, 0, NI_NAMEREQD);
-
-            if (!err) {
-                if (name != NULL && nameLength > 0 && !memchr(name, '\0', nameLength)) {
-                    return -1;
-                }
-
-                return 0;
-            }
-
-            if (err != EAI_NONAME) {
-                return -1;
-            }
-
-            return enet_address_get_host_ip(address, name, nameLength);
-        }
-
-        int enet_socket_bind(ENetSocket socket, const ENetAddress *address) {
-            struct sockaddr_in6 sin;
-            memset(&sin, 0, sizeof(struct sockaddr_in6));
-            sin.sin6_family = AF_INET6;
-
-            if (address != NULL) {
-                sin.sin6_port       = ENET_HOST_TO_NET_16(address->port);
-                sin.sin6_addr       = address->host;
-                sin.sin6_scope_id   = address->sin6_scope_id;
-            } else {
-                sin.sin6_port       = 0;
-                sin.sin6_addr       = ENET_HOST_ANY;
-                sin.sin6_scope_id   = 0;
-            }
-
-            return bind(socket, (struct sockaddr *)&sin, sizeof(struct sockaddr_in6));
-        }
-
-        int enet_socket_get_address(ENetSocket socket, ENetAddress *address) {
-            struct sockaddr_in6 sin;
-            socklen_t sinLength = sizeof(struct sockaddr_in6);
-
-            if (getsockname(socket, (struct sockaddr *)&sin, &sinLength) == -1) {
-                return -1;
-            }
-
-            address->host           = sin.sin6_addr;
-            address->port           = ENET_NET_TO_HOST_16(sin.sin6_port);
-            address->sin6_scope_id  = sin.sin6_scope_id;
-
-            return 0;
-        }
-
-        int enet_socket_listen(ENetSocket socket, int backlog) {
-            return listen(socket, backlog < 0 ? SOMAXCONN : backlog);
-        }
-
-        ENetSocket enet_socket_create(ENetSocketType type) {
-            return socket(PF_INET6, type == ENET_SOCKET_TYPE_DATAGRAM ? SOCK_DGRAM : SOCK_STREAM, 0);
-        }
-
-        int enet_socket_set_option(ENetSocket socket, ENetSocketOption option, int value) {
-            int result = -1;
-
-            switch (option) {
-                case ENET_SOCKOPT_NONBLOCK:
-                    result = fcntl(socket, F_SETFL, (value ? O_NONBLOCK : 0) | (fcntl(socket, F_GETFL) & ~O_NONBLOCK));
-                    break;
-
-                case ENET_SOCKOPT_BROADCAST:
-                    result = setsockopt(socket, SOL_SOCKET, SO_BROADCAST, (char *)&value, sizeof(int));
-                    break;
-
-                case ENET_SOCKOPT_REUSEADDR:
-                    result = setsockopt(socket, SOL_SOCKET, SO_REUSEADDR, (char *)&value, sizeof(int));
-                    break;
-
-                case ENET_SOCKOPT_RCVBUF:
-                    result = setsockopt(socket, SOL_SOCKET, SO_RCVBUF, (char *)&value, sizeof(int));
-                    break;
-
-                case ENET_SOCKOPT_SNDBUF:
-                    result = setsockopt(socket, SOL_SOCKET, SO_SNDBUF, (char *)&value, sizeof(int));
-                    break;
-
-                case ENET_SOCKOPT_RCVTIMEO: {
-                    struct timeval timeVal;
-                    timeVal.tv_sec  = value / 1000;
-                    timeVal.tv_usec = (value % 1000) * 1000;
-                    result = setsockopt(socket, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeVal, sizeof(struct timeval));
-                    break;
-                }
-
-                case ENET_SOCKOPT_SNDTIMEO: {
-                    struct timeval timeVal;
-                    timeVal.tv_sec  = value / 1000;
-                    timeVal.tv_usec = (value % 1000) * 1000;
-                    result = setsockopt(socket, SOL_SOCKET, SO_SNDTIMEO, (char *)&timeVal, sizeof(struct timeval));
-                    break;
-                }
-
-                case ENET_SOCKOPT_NODELAY:
-                    result = setsockopt(socket, IPPROTO_TCP, TCP_NODELAY, (char *)&value, sizeof(int));
-                    break;
-
-                case ENET_SOCKOPT_IPV6_V6ONLY:
-                    result = setsockopt(socket, IPPROTO_IPV6, IPV6_V6ONLY, (char *)&value, sizeof(int));
-                    break;
-
-                default:
-                    break;
-            }
-
-            return result == -1 ? -1 : 0;
-        }
-
-        int enet_socket_get_option(ENetSocket socket, ENetSocketOption option, int *value) {
-            int result = -1;
-            socklen_t len;
-
-            switch (option) {
-                case ENET_SOCKOPT_ERROR:
-                    len    = sizeof(int);
-                    result = getsockopt(socket, SOL_SOCKET, SO_ERROR, value, &len);
-                    break;
-
-                default:
-                    break;
-            }
-
-            return result == -1 ? -1 : 0;
-        }
-
-        int enet_socket_connect(ENetSocket socket, const ENetAddress *address) {
-            struct sockaddr_in6 sin;
-            int result;
-
-            memset(&sin, 0, sizeof(struct sockaddr_in6));
-
-            sin.sin6_family     = AF_INET6;
-            sin.sin6_port       = ENET_HOST_TO_NET_16(address->port);
-            sin.sin6_addr       = address->host;
-            sin.sin6_scope_id   = address->sin6_scope_id;
-
-            result = connect(socket, (struct sockaddr *)&sin, sizeof(struct sockaddr_in6));
-
-            if (result == -1 && errno == EINPROGRESS) {
-                return 0;
-            }
-
-            return result;
-        }
-
-        ENetSocket enet_socket_accept(ENetSocket socket, ENetAddress *address) {
-            int result;
-            struct sockaddr_in6 sin;
-            socklen_t sinLength = sizeof(struct sockaddr_in6);
-
-            result = accept(socket,address != NULL ? (struct sockaddr *)&sin : NULL, address != NULL ? &sinLength : NULL);
-
-            if (result == -1) {
-                return ENET_SOCKET_NULL;
-            }
-
-            if (address != NULL) {
-                address->host = sin.sin6_addr;
-                address->port = ENET_NET_TO_HOST_16 (sin.sin6_port);
-                address->sin6_scope_id = sin.sin6_scope_id;
-            }
-
-            return result;
-        }
-
-        int enet_socket_shutdown(ENetSocket socket, ENetSocketShutdown how) {
-            return shutdown(socket, (int)how);
-        }
-
-        void enet_socket_destroy(ENetSocket socket) {
-            if (socket != -1) {
-                close(socket);
-            }
-        }
-
-        int enet_socket_send(ENetSocket socket, const ENetAddress *address, const ENetBuffer *buffers, size_t bufferCount) {
-            struct msghdr msgHdr;
-            struct sockaddr_in6 sin;
-            int sentLength;
-
-            memset(&msgHdr, 0, sizeof(struct msghdr));
-
-            if (address != NULL) {
-                memset(&sin, 0, sizeof(struct sockaddr_in6));
-
-                sin.sin6_family     = AF_INET6;
-                sin.sin6_port       = ENET_HOST_TO_NET_16(address->port);
-                sin.sin6_addr       = address->host;
-                sin.sin6_scope_id   = address->sin6_scope_id;
-
-                msgHdr.msg_name    = &sin;
-                msgHdr.msg_namelen = sizeof(struct sockaddr_in6);
-            }
-
-            msgHdr.msg_iov    = (struct iovec *)buffers;
-            msgHdr.msg_iovlen = bufferCount;
-
-            sentLength = sendmsg(socket, &msgHdr, MSG_NOSIGNAL);
-
-            if (sentLength == -1) {
-                if (errno == EWOULDBLOCK) {
-                    return 0;
-                }
-
-                return -1;
-            }
-
-            return sentLength;
-        }
-
-        int enet_socket_receive(ENetSocket socket, ENetAddress *address, ENetBuffer *buffers, size_t bufferCount) {
-            struct msghdr msgHdr;
-            struct sockaddr_in6 sin;
-            int recvLength;
-
-            memset(&msgHdr, 0, sizeof(struct msghdr));
-
-            if (address != NULL) {
-                msgHdr.msg_name    = &sin;
-                msgHdr.msg_namelen = sizeof(struct sockaddr_in6);
-            }
-
-            msgHdr.msg_iov    = (struct iovec *)buffers;
-            msgHdr.msg_iovlen = bufferCount;
-
-            recvLength = recvmsg(socket, &msgHdr, MSG_NOSIGNAL);
-
-            if (recvLength == -1) {
-                if (errno == EWOULDBLOCK) {
-                    return 0;
-                }
-
-                return -1;
-            }
-
-            if (msgHdr.msg_flags & MSG_TRUNC) {
-                return -1;
-            }
-
-            if (address != NULL) {
-                address->host           = sin.sin6_addr;
-                address->port           = ENET_NET_TO_HOST_16(sin.sin6_port);
-                address->sin6_scope_id  = sin.sin6_scope_id;
-            }
-
-            return recvLength;
-        }
-
-        int enet_socketset_select(ENetSocket maxSocket, ENetSocketSet *readSet, ENetSocketSet *writeSet, enet_uint32 timeout) {
-            struct timeval timeVal;
-
-            timeVal.tv_sec  = timeout / 1000;
-            timeVal.tv_usec = (timeout % 1000) * 1000;
-
-            return select(maxSocket + 1, readSet, writeSet, NULL, &timeVal);
-        }
-
-        int enet_socket_wait(ENetSocket socket, enet_uint32 *condition, enet_uint64 timeout) {
-            struct pollfd pollSocket;
-            int pollCount;
-
-            pollSocket.fd     = socket;
-            pollSocket.events = 0;
-
-            if (*condition & ENET_SOCKET_WAIT_SEND) {
-                pollSocket.events |= POLLOUT;
-            }
-
-            if (*condition & ENET_SOCKET_WAIT_RECEIVE) {
-                pollSocket.events |= POLLIN;
-            }
-
-            pollCount = poll(&pollSocket, 1, timeout);
-
-            if (pollCount < 0) {
-                if (errno == EINTR && *condition & ENET_SOCKET_WAIT_INTERRUPT) {
-                    *condition = ENET_SOCKET_WAIT_INTERRUPT;
-
-                    return 0;
-                }
-
-                return -1;
-            }
-
-            *condition = ENET_SOCKET_WAIT_NONE;
-
-            if (pollCount == 0) {
-                return 0;
-            }
-
-            if (pollSocket.revents & POLLOUT) {
-                *condition |= ENET_SOCKET_WAIT_SEND;
-            }
-
-            if (pollSocket.revents & POLLIN) {
-                *condition |= ENET_SOCKET_WAIT_RECEIVE;
-            }
-
-            return 0;
-        }
-    #endif
-
-// =======================================================================//
-// !
-// ! Platform Specific (Win)
-// !
-// =======================================================================//
-
-    #ifdef _WIN32
-        #ifdef __MINGW32__
-            const char *inet_ntop(int af, const void *src, char *dst, socklen_t cnt) {
-                if (af == AF_INET) {
-                    struct sockaddr_in in;
-                    memset(&in, 0, sizeof(in));
-                    in.sin_family = AF_INET;
-                    memcpy(&in.sin_addr, src, sizeof(struct in_addr));
-                    getnameinfo((struct sockaddr *)&in, sizeof(struct sockaddr_in), dst, cnt, NULL, 0, NI_NUMERICHOST);
-                    return dst;
-                } else if (af == AF_INET6) {
-                    struct sockaddr_in6 in;
-                    memset(&in, 0, sizeof(in));
-                    in.sin6_family = AF_INET6;
-                    memcpy(&in.sin6_addr, src, sizeof(struct in_addr6));
-                    getnameinfo((struct sockaddr *)&in, sizeof(struct sockaddr_in6), dst, cnt, NULL, 0, NI_NUMERICHOST);
-                    return dst;
-                }
-
-                return NULL;
-            }
-
-            #define NS_INADDRSZ  4
-            #define NS_IN6ADDRSZ 16
-            #define NS_INT16SZ   2
-
-            int inet_pton4(const char *src, char *dst) {
-                uint8_t tmp[NS_INADDRSZ], *tp;
-
-                int saw_digit = 0;
-                int octets = 0;
-                *(tp = tmp) = 0;
-
-                int ch;
-
-                while ((ch = *src++) != '\0') {
-                    if (ch >= '0' && ch <= '9') {
-                        uint32_t n = *tp * 10 + (ch - '0');
-
-                        if (saw_digit && *tp == 0)
-                            return 0;
-
-                        if (n > 255)
-                            return 0;
-
-                        *tp = n;
-
-                        if (!saw_digit) {
-                            if (++octets > 4)
-                                return 0;
-
-                            saw_digit = 1;
-                        }
-                    } else if (ch == '.' && saw_digit) {
-                        if (octets == 4)
-                            return 0;
-
-                        *++tp = 0;
-                        saw_digit = 0;
-                    } else
-                        return 0;
-                }
-                if (octets < 4)
-                    return 0;
-
-                memcpy(dst, tmp, NS_INADDRSZ);
-
-                return 1;
-            }
-
-            int inet_pton6(const char *src, char *dst) {
-                static const char xdigits[] = "0123456789abcdef";
-                uint8_t tmp[NS_IN6ADDRSZ];
-
-                uint8_t *tp = (uint8_t*)memset(tmp, '\0', NS_IN6ADDRSZ);
-                uint8_t *endp = tp + NS_IN6ADDRSZ;
-                uint8_t *colonp = NULL;
-
-                /* Leading :: requires some special handling. */
-                if (*src == ':') {
-                    if (*++src != ':')
-                        return 0;
-                }
-
-                const char *curtok = src;
-                int saw_xdigit = 0;
-                uint32_t val = 0;
-                int ch;
-                while ((ch = tolower(*src++)) != '\0') {
-                    const char *pch = strchr(xdigits, ch);
-
-                    if (pch != NULL) {
-                        val <<= 4;
-                        val |= (pch - xdigits);
-
-                        if (val > 0xffff)
-                            return 0;
-
-                        saw_xdigit = 1;
-
-                        continue;
-                    }
-
-                    if (ch == ':') {
-                        curtok = src;
-                        if (!saw_xdigit) {
-                            if (colonp)
-                                return 0;
-
-                            colonp = tp;
-
-                            continue;
-                        } else if (*src == '\0') {
-                            return 0;
-                        }
-
-                        if (tp + NS_INT16SZ > endp)
-                            return 0;
-
-                        *tp++ = (uint8_t) (val >> 8) & 0xff;
-                        *tp++ = (uint8_t) val & 0xff;
-                        saw_xdigit = 0;
-                        val = 0;
-
-                        continue;
-                    }
-
-                    if (ch == '.' && ((tp + NS_INADDRSZ) <= endp) && inet_pton4(curtok, (char*)tp) > 0) {
-                        tp += NS_INADDRSZ;
-                        saw_xdigit = 0;
-                        break; /* '\0' was seen by inet_pton4(). */
-                    }
-
-                    return 0;
-                }
-
-                if (saw_xdigit) {
-                    if (tp + NS_INT16SZ > endp)
-                        return 0;
-
-                    *tp++ = (uint8_t) (val >> 8) & 0xff;
-                    *tp++ = (uint8_t) val & 0xff;
-                }
-
-                if (colonp != NULL) {
-                    /*
-                     * Since some memmove()'s erroneously fail to handle
-                     * overlapping regions, we'll do the shift by hand.
-                     */
-                    const int n = tp - colonp;
-
-                    if (tp == endp)
-                        return 0;
-
-                    for (int i = 1; i <= n; i++) {
-                        endp[-i] = colonp[n - i];
-                        colonp[n - i] = 0;
-                    }
-
-                    tp = endp;
-                }
-
-                if (tp != endp)
-                    return 0;
-
-                memcpy(dst, tmp, NS_IN6ADDRSZ);
-
-                return 1;
-            }
-
-            int inet_pton(int af, const char *src, struct in6_addr *dst) {
-                switch (af) {
-                    case AF_INET:
-                        return inet_pton4(src, (char *)dst);
-
-                    case AF_INET6:
-                        return inet_pton6(src, (char *)dst);
-
-                    default:
-                        return -1;
-                }
-            }
-        #endif
-
-        int enet_initialize(void) {
-            WORD versionRequested = MAKEWORD(1, 1);
-            WSADATA wsaData;
-
-            if (WSAStartup(versionRequested, &wsaData)) {
-                return -1;
-            }
-
-            if (LOBYTE(wsaData.wVersion) != 1 || HIBYTE(wsaData.wVersion) != 1) {
-                WSACleanup();
-                return -1;
-            }
-
-            timeBeginPeriod(1);
-            return 0;
-        }
-
-        void enet_deinitialize(void) {
-            timeEndPeriod(1);
-            WSACleanup();
-        }
-
-        enet_uint64 enet_host_random_seed(void) {
-            return (enet_uint64) timeGetTime();
-        }
-
-        int enet_address_set_host_ip(ENetAddress *address, const char *name) {
-            enet_uint8 vals[4] = { 0, 0, 0, 0 };
-            int i;
-
-            for (i = 0; i < 4; ++i) {
-                const char *next = name + 1;
-                if (*name != '0') {
-                    long val = strtol(name, (char **)&next, 10);
-
-                    if (val < 0 || val > 255 || next == name || next - name > 3) {
-                        return -1;
-                    }
-
-                    vals[i] = (enet_uint8) val;
-                }
-
-                if (*next != (i < 3 ? '.' : '\0')) {
-                    return -1;
-                }
-
-                name = next + 1;
-            }
-
-            memcpy(&address->host, vals, sizeof(enet_uint32));
-
-            return 0;
-        }
-
-        int enet_address_set_host(ENetAddress *address, const char *name) {
-            struct hostent *hostEntry = NULL;
-            hostEntry = gethostbyname(name);
-
-            if (hostEntry == NULL || hostEntry->h_addrtype != AF_INET) {
-                if (!inet_pton(AF_INET6, name, &address->host)) {
-                    return -1;
-                }
-
-                return 0;
-            }
-
-            ((enet_uint32 *)&address->host.s6_addr)[0] = 0;
-            ((enet_uint32 *)&address->host.s6_addr)[1] = 0;
-            ((enet_uint32 *)&address->host.s6_addr)[2] = htonl(0xffff);
-            ((enet_uint32 *)&address->host.s6_addr)[3] = *(enet_uint32 *)hostEntry->h_addr_list[0];
-
-            return 0;
-        }
-
-        int enet_address_get_host_ip(const ENetAddress *address, char *name, size_t nameLength) {
-            if (inet_ntop(AF_INET6, (PVOID)&address->host, name, nameLength) == NULL) {
-                return -1;
-            }
-
-            return 0;
-        }
-
-        int enet_address_get_host(const ENetAddress *address, char *name, size_t nameLength) {
-            struct in6_addr in;
-            struct hostent *hostEntry = NULL;
-
-            in = address->host;
-            hostEntry = gethostbyaddr((char *)&in, sizeof(struct in6_addr), AF_INET6);
-
-            if (hostEntry == NULL) {
-                return enet_address_get_host_ip(address, name, nameLength);
-            } else {
-                size_t hostLen = strlen(hostEntry->h_name);
-                if (hostLen >= nameLength) {
-                    return -1;
-                }
-                memcpy(name, hostEntry->h_name, hostLen + 1);
-            }
-
-            return 0;
-        }
-
-        int enet_socket_bind(ENetSocket socket, const ENetAddress *address) {
-            struct sockaddr_in6 sin;
-            memset(&sin, 0, sizeof(struct sockaddr_in6));
-            sin.sin6_family = AF_INET6;
-
-            if (address != NULL) {
-                sin.sin6_port       = ENET_HOST_TO_NET_16 (address->port);
-                sin.sin6_addr       = address->host;
-                sin.sin6_scope_id   = address->sin6_scope_id;
-            } else {
-                sin.sin6_port       = 0;
-                sin.sin6_addr       = in6addr_any;
-                sin.sin6_scope_id   = 0;
-            }
-
-            return bind(socket, (struct sockaddr *)&sin, sizeof(struct sockaddr_in6)) == SOCKET_ERROR ? -1 : 0;
-        }
-
-        int enet_socket_get_address(ENetSocket socket, ENetAddress *address) {
-            struct sockaddr_in6 sin;
-            int sinLength = sizeof(struct sockaddr_in6);
-
-            if (getsockname(socket, (struct sockaddr *)&sin, &sinLength) == -1) {
-                return -1;
-            }
-
-            address->host           = sin.sin6_addr;
-            address->port           = ENET_NET_TO_HOST_16(sin.sin6_port);
-            address->sin6_scope_id  = sin.sin6_scope_id;
-
-            return 0;
-        }
-
-        int enet_socket_listen(ENetSocket socket, int backlog) {
-            return listen(socket, backlog < 0 ? SOMAXCONN : backlog) == SOCKET_ERROR ? -1 : 0;
-        }
-
-        ENetSocket enet_socket_create(ENetSocketType type) {
-            return socket(PF_INET6, type == ENET_SOCKET_TYPE_DATAGRAM ? SOCK_DGRAM : SOCK_STREAM, 0);
-        }
-
-        int enet_socket_set_option(ENetSocket socket, ENetSocketOption option, int value) {
-            int result = SOCKET_ERROR;
-
-            switch (option) {
-                case ENET_SOCKOPT_NONBLOCK: {
-                    u_long nonBlocking = (u_long) value;
-                    result = ioctlsocket(socket, FIONBIO, &nonBlocking);
-                    break;
-                }
-
-                case ENET_SOCKOPT_BROADCAST:
-                    result = setsockopt(socket, SOL_SOCKET, SO_BROADCAST, (char *)&value, sizeof(int));
-                    break;
-
-                case ENET_SOCKOPT_REUSEADDR:
-                    result = setsockopt(socket, SOL_SOCKET, SO_REUSEADDR, (char *)&value, sizeof(int));
-                    break;
-
-                case ENET_SOCKOPT_RCVBUF:
-                    result = setsockopt(socket, SOL_SOCKET, SO_RCVBUF, (char *)&value, sizeof(int));
-                    break;
-
-                case ENET_SOCKOPT_SNDBUF:
-                    result = setsockopt(socket, SOL_SOCKET, SO_SNDBUF, (char *)&value, sizeof(int));
-                    break;
-
-                case ENET_SOCKOPT_RCVTIMEO:
-                    result = setsockopt(socket, SOL_SOCKET, SO_RCVTIMEO, (char *)&value, sizeof(int));
-                    break;
-
-                case ENET_SOCKOPT_SNDTIMEO:
-                    result = setsockopt(socket, SOL_SOCKET, SO_SNDTIMEO, (char *)&value, sizeof(int));
-                    break;
-
-                case ENET_SOCKOPT_NODELAY:
-                    result = setsockopt(socket, IPPROTO_TCP, TCP_NODELAY, (char *)&value, sizeof(int));
-                    break;
-
-                case ENET_SOCKOPT_IPV6_V6ONLY:
-                    result = setsockopt(socket, IPPROTO_IPV6, IPV6_V6ONLY, (char *)&value, sizeof(int));
-                    break;
-
-                default:
-                    break;
-            }
-            return result == SOCKET_ERROR ? -1 : 0;
-        }
-
-        int enet_socket_get_option(ENetSocket socket, ENetSocketOption option, int *value) {
-            int result = SOCKET_ERROR, len;
-
-            switch (option) {
-                case ENET_SOCKOPT_ERROR:
-                    len    = sizeof(int);
-                    result = getsockopt(socket, SOL_SOCKET, SO_ERROR, (char *)value, &len);
-                    break;
-
-                default:
-                    break;
-            }
-            return result == SOCKET_ERROR ? -1 : 0;
-        }
-
-        int enet_socket_connect(ENetSocket socket, const ENetAddress *address) {
-            struct sockaddr_in6 sin;
-            int result;
-
-            memset(&sin, 0, sizeof(struct sockaddr_in6));
-
-            sin.sin6_family     = AF_INET6;
-            sin.sin6_port       = ENET_HOST_TO_NET_16(address->port);
-            sin.sin6_addr       = address->host;
-            sin.sin6_scope_id   = address->sin6_scope_id;
-
-            result = connect(socket, (struct sockaddr *)&sin, sizeof(struct sockaddr_in6));
-
-            if (result == SOCKET_ERROR && WSAGetLastError() != WSAEWOULDBLOCK) {
-                return -1;
-            }
-
-            return 0;
-        }
-
-        ENetSocket enet_socket_accept(ENetSocket socket, ENetAddress *address) {
-            SOCKET result;
-            struct sockaddr_in6 sin;
-            int sinLength = sizeof(struct sockaddr_in6);
-
-            result = accept(socket, address != NULL ? (struct sockaddr *)&sin : NULL, address != NULL ? &sinLength : NULL);
-
-            if (result == INVALID_SOCKET) {
-                return ENET_SOCKET_NULL;
-            }
-
-            if (address != NULL) {
-                address->host           = sin.sin6_addr;
-                address->port           = ENET_NET_TO_HOST_16(sin.sin6_port);
-                address->sin6_scope_id  = sin.sin6_scope_id;
-            }
-
-            return result;
-        }
-
-        int enet_socket_shutdown(ENetSocket socket, ENetSocketShutdown how) {
-            return shutdown(socket, (int)how) == SOCKET_ERROR ? -1 : 0;
-        }
-
-        void enet_socket_destroy(ENetSocket socket) {
-            if (socket != INVALID_SOCKET) {
-                closesocket(socket);
-            }
-        }
-
-        int enet_socket_send(ENetSocket socket, const ENetAddress *address, const ENetBuffer *buffers, size_t bufferCount) {
-            struct sockaddr_in6 sin;
-            DWORD sentLength;
-
-            if (address != NULL) {
-                memset(&sin, 0, sizeof(struct sockaddr_in6));
-
-                sin.sin6_family     = AF_INET6;
-                sin.sin6_port       = ENET_HOST_TO_NET_16(address->port);
-                sin.sin6_addr       = address->host;
-                sin.sin6_scope_id   = address->sin6_scope_id;
-            }
-
-            if (WSASendTo(socket,
-                (LPWSABUF) buffers,
-                (DWORD) bufferCount,
-                &sentLength,
-                0,
-                address != NULL ? (struct sockaddr *)&sin : NULL,
-                address != NULL ? sizeof(struct sockaddr_in6) : 0,
-                NULL,
-                NULL) == SOCKET_ERROR
-            ) {
-                return (WSAGetLastError() == WSAEWOULDBLOCK) ? 0 : 1;
-            }
-
-            return (int)sentLength;
-        }
-
-        int enet_socket_receive(ENetSocket socket, ENetAddress *address, ENetBuffer *buffers, size_t bufferCount) {
-            INT sinLength = sizeof(struct sockaddr_in6);
-            DWORD flags   = 0, recvLength;
-            struct sockaddr_in6 sin;
-
-            if (WSARecvFrom(socket,
-                (LPWSABUF) buffers,
-                (DWORD) bufferCount,
-                &recvLength,
-                &flags,
-                address != NULL ? (struct sockaddr *)&sin : NULL,
-                address != NULL ? &sinLength : NULL,
-                NULL,
-                NULL) == SOCKET_ERROR
-            ) {
-                switch (WSAGetLastError()) {
-                    case WSAEWOULDBLOCK:
-                    case WSAECONNRESET:
-                        return 0;
-                }
-
-                return -1;
-            }
-
-            if (flags & MSG_PARTIAL) {
-                return -1;
-            }
-
-            if (address != NULL) {
-                address->host           = sin.sin6_addr;
-                address->port           = ENET_NET_TO_HOST_16(sin.sin6_port);
-                address->sin6_scope_id  = sin.sin6_scope_id;
-            }
-
-            return (int)recvLength;
-        }
-
-        int enet_socketset_select(ENetSocket maxSocket, ENetSocketSet *readSet, ENetSocketSet *writeSet, enet_uint32 timeout) {
-            struct timeval timeVal;
-
-            timeVal.tv_sec  = timeout / 1000;
-            timeVal.tv_usec = (timeout % 1000) * 1000;
-
-            return select(maxSocket + 1, readSet, writeSet, NULL, &timeVal);
-        }
-
-        int enet_socket_wait(ENetSocket socket, enet_uint32 *condition, enet_uint64 timeout) {
-            fd_set readSet, writeSet;
-            struct timeval timeVal;
-            int selectCount;
-
-            timeVal.tv_sec  = timeout / 1000;
-            timeVal.tv_usec = (timeout % 1000) * 1000;
-
-            FD_ZERO(&readSet);
-            FD_ZERO(&writeSet);
-
-            if (*condition & ENET_SOCKET_WAIT_SEND) {
-                FD_SET(socket, &writeSet);
-            }
-
-            if (*condition & ENET_SOCKET_WAIT_RECEIVE) {
-                FD_SET(socket, &readSet);
-            }
-
-            selectCount = select(socket + 1, &readSet, &writeSet, NULL, &timeVal);
-
-            if (selectCount < 0) {
-                return -1;
-            }
-
-            *condition = ENET_SOCKET_WAIT_NONE;
-
-            if (selectCount == 0) {
-                return 0;
-            }
-
-            if (FD_ISSET(socket, &writeSet)) {
-                *condition |= ENET_SOCKET_WAIT_SEND;
-            }
-
-            if (FD_ISSET(socket, &readSet)) {
-                *condition |= ENET_SOCKET_WAIT_RECEIVE;
-            }
-
-            return 0;
-        }
-    #endif
-
-#ifdef __cplusplus
-}
-#endif
-#endif
-#endif
+/*
+ *  ENet reliable UDP networking library 
+ *  Copyright (c) 2018 Lee Salzman, Vladyslav Hrytsenko, Dominik Madarász, Stanislav Denisov
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+#ifndef ENET_INCLUDE_H
+#define ENET_INCLUDE_H
+
+#include <stdlib.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <time.h>
+
+#define ENET_VERSION_MAJOR 2
+#define ENET_VERSION_MINOR 0
+#define ENET_VERSION_PATCH 9
+#define ENET_VERSION_CREATE(major, minor, patch) (((major)<<16) | ((minor)<<8) | (patch))
+#define ENET_VERSION_GET_MAJOR(version) (((version)>>16)&0xFF)
+#define ENET_VERSION_GET_MINOR(version) (((version)>>8)&0xFF)
+#define ENET_VERSION_GET_PATCH(version) ((version)&0xFF)
+#define ENET_VERSION ENET_VERSION_CREATE(ENET_VERSION_MAJOR, ENET_VERSION_MINOR, ENET_VERSION_PATCH)
+
+#define ENET_TIME_OVERFLOW 86400000
+#define ENET_TIME_LESS(a, b) ((a) - (b) >= ENET_TIME_OVERFLOW)
+#define ENET_TIME_GREATER(a, b) ((b) - (a) >= ENET_TIME_OVERFLOW)
+#define ENET_TIME_LESS_EQUAL(a, b) (! ENET_TIME_GREATER (a, b))
+#define ENET_TIME_GREATER_EQUAL(a, b) (! ENET_TIME_LESS (a, b))
+#define ENET_TIME_DIFFERENCE(a, b) ((a) - (b) >= ENET_TIME_OVERFLOW ? (b) - (a) : (a) - (b))
+
+// =======================================================================//
+// !
+// ! System differences
+// !
+// =======================================================================//
+
+#if defined(_WIN32)
+    #if defined(_MSC_VER) && defined(ENET_IMPLEMENTATION)
+        #pragma warning (disable: 4267) /* size_t to int conversion */
+        #pragma warning (disable: 4244) /* 64bit to 32bit int */
+        #pragma warning (disable: 4018) /* signed/unsigned mismatch */
+        #pragma warning (disable: 4146) /* unary minus operator applied to unsigned type */
+    #endif
+
+    #ifndef ENET_NO_PRAGMA_LINK
+        #pragma comment(lib, "ws2_32.lib")
+        #pragma comment(lib, "winmm.lib")
+    #endif
+
+    #if _MSC_VER >= 1910
+        /* It looks like there were changes as of Visual Studio 2017 and there are no 32/64 bit
+           versions of _InterlockedExchange[operation], only InterlockedExchange[operation]
+           (without leading underscore), so we have to distinguish between compiler versions */
+        #define NOT_UNDERSCORED_INTERLOCKED_EXCHANGE
+    #endif
+
+    #ifdef __GNUC__
+        #if (_WIN32_WINNT < 0x0501)
+            #undef _WIN32_WINNT
+            #define _WIN32_WINNT 0x0501
+        #endif
+    #endif
+
+    #include <winsock2.h>
+    #include <ws2tcpip.h>
+    #include <mmsystem.h>
+    #include <intrin.h>
+
+    #if defined(_WIN32) && defined(_MSC_VER)
+        #if _MSC_VER < 1900
+            typedef struct timespec {
+                long tv_sec;
+                long tv_nsec;
+            };
+        #endif
+        #define CLOCK_MONOTONIC 0
+    #endif
+
+    typedef SOCKET ENetSocket;
+    #define ENET_SOCKET_NULL INVALID_SOCKET
+
+    #define ENET_HOST_TO_NET_16(value) (htons(value))
+    #define ENET_HOST_TO_NET_32(value) (htonl(value))
+
+    #define ENET_NET_TO_HOST_16(value) (ntohs(value))
+    #define ENET_NET_TO_HOST_32(value) (ntohl(value))
+
+    typedef struct {
+        size_t dataLength;
+        void * data;
+    } ENetBuffer;
+
+    #define ENET_CALLBACK __cdecl
+
+    #ifdef ENET_DLL
+        #ifdef ENET_IMPLEMENTATION
+            #define ENET_API __declspec(dllexport)
+        #else
+            #define ENET_API __declspec(dllimport)
+        #endif
+    #else
+        #define ENET_API extern
+    #endif
+
+    typedef fd_set ENetSocketSet;
+
+    #define ENET_SOCKETSET_EMPTY(sockset)          FD_ZERO(&(sockset))
+    #define ENET_SOCKETSET_ADD(sockset, socket)    FD_SET(socket, &(sockset))
+    #define ENET_SOCKETSET_REMOVE(sockset, socket) FD_CLR(socket, &(sockset))
+    #define ENET_SOCKETSET_CHECK(sockset, socket)  FD_ISSET(socket, &(sockset))
+#else
+    #include <sys/types.h>
+    #include <sys/ioctl.h>
+    #include <sys/time.h>
+    #include <sys/socket.h>
+    #include <poll.h>
+    #include <arpa/inet.h>
+    #include <netinet/in.h>
+    #include <netinet/tcp.h>
+    #include <netdb.h>
+    #include <unistd.h>
+    #include <string.h>
+    #include <errno.h>
+    #include <fcntl.h>
+
+    #ifdef __APPLE__
+        #include <mach/clock.h>
+        #include <mach/mach.h>
+        #include <Availability.h>
+    #endif
+
+    #ifndef MSG_NOSIGNAL
+        #define MSG_NOSIGNAL 0
+    #endif
+
+    #ifdef MSG_MAXIOVLEN
+        #define ENET_BUFFER_MAXIMUM MSG_MAXIOVLEN
+    #endif
+
+    typedef int ENetSocket;
+
+    #define ENET_SOCKET_NULL -1
+
+    #define ENET_HOST_TO_NET_16(value) (htons(value))
+    #define ENET_HOST_TO_NET_32(value) (htonl(value))
+
+    #define ENET_NET_TO_HOST_16(value) (ntohs(value))
+    #define ENET_NET_TO_HOST_32(value) (ntohl(value))
+
+    typedef struct {
+        void * data;
+        size_t dataLength;
+    } ENetBuffer;
+
+    #define ENET_CALLBACK
+    #define ENET_API extern
+
+    typedef fd_set ENetSocketSet;
+
+    #define ENET_SOCKETSET_EMPTY(sockset)          FD_ZERO(&(sockset))
+    #define ENET_SOCKETSET_ADD(sockset, socket)    FD_SET(socket, &(sockset))
+    #define ENET_SOCKETSET_REMOVE(sockset, socket) FD_CLR(socket, &(sockset))
+    #define ENET_SOCKETSET_CHECK(sockset, socket)  FD_ISSET(socket, &(sockset))
+#endif
+
+#ifndef ENET_BUFFER_MAXIMUM
+    #define ENET_BUFFER_MAXIMUM (1 + 2 * ENET_PROTOCOL_MAXIMUM_PACKET_COMMANDS)
+#endif
+
+#define ENET_MAX(x, y) ((x) > (y) ? (x) : (y))
+#define ENET_MIN(x, y) ((x) < (y) ? (x) : (y))
+#define ENET_IPV6           1
+#define ENET_HOST_ANY       in6addr_any
+#define ENET_HOST_BROADCAST 0xFFFFFFFFU
+#define ENET_PORT_ANY       0
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// =======================================================================//
+// !
+// ! Basic stuff
+// !
+// =======================================================================//
+
+    typedef uint8_t   enet_uint8;
+    typedef uint16_t enet_uint16;
+    typedef uint32_t enet_uint32;
+    typedef uint64_t enet_uint64;
+
+    typedef enet_uint32 ENetVersion;
+
+    typedef struct _ENetCallbacks {
+        void *(ENET_CALLBACK *malloc) (size_t size);
+        void (ENET_CALLBACK *free) (void *memory);
+        void (ENET_CALLBACK *no_memory) (void);
+    } ENetCallbacks;
+
+    extern void *enet_malloc(size_t);
+    extern void enet_free(void *);
+
+// =======================================================================//
+// !
+// ! List
+// !
+// =======================================================================//
+
+    typedef struct _ENetListNode {
+        struct _ENetListNode *next;
+        struct _ENetListNode *previous;
+    } ENetListNode;
+
+    typedef ENetListNode *ENetListIterator;
+
+    typedef struct _ENetList {
+        ENetListNode sentinel;
+    } ENetList;
+
+    extern ENetListIterator enet_list_insert(ENetListIterator, void *);
+    extern ENetListIterator enet_list_move(ENetListIterator, void *, void *);
+
+    extern void *enet_list_remove(ENetListIterator);
+    extern void enet_list_clear(ENetList *);
+    extern size_t enet_list_size(ENetList *);
+
+    #define enet_list_begin(list) ((list)->sentinel.next)
+    #define enet_list_end(list) (&(list)->sentinel)
+    #define enet_list_empty(list) (enet_list_begin(list) == enet_list_end(list))
+    #define enet_list_next(iterator) ((iterator)->next)
+    #define enet_list_previous(iterator) ((iterator)->previous)
+    #define enet_list_front(list) ((void *) (list)->sentinel.next)
+    #define enet_list_back(list) ((void *) (list)->sentinel.previous)
+
+// =======================================================================//
+// !
+// ! Protocol
+// !
+// =======================================================================//
+
+    enum {
+        ENET_PROTOCOL_MINIMUM_MTU             = 576,
+        ENET_PROTOCOL_MAXIMUM_MTU             = 4096,
+        ENET_PROTOCOL_MAXIMUM_PACKET_COMMANDS = 32,
+        ENET_PROTOCOL_MINIMUM_WINDOW_SIZE     = 4096,
+        ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE     = 65536,
+        ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT   = 1,
+        ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT   = 255,
+        ENET_PROTOCOL_MAXIMUM_PEER_ID         = 0xFFF,
+        ENET_PROTOCOL_MAXIMUM_FRAGMENT_COUNT  = 1024 * 1024
+    };
+
+    typedef enum _ENetProtocolCommand {
+        ENET_PROTOCOL_COMMAND_NONE                     = 0,
+        ENET_PROTOCOL_COMMAND_ACKNOWLEDGE              = 1,
+        ENET_PROTOCOL_COMMAND_CONNECT                  = 2,
+        ENET_PROTOCOL_COMMAND_VERIFY_CONNECT           = 3,
+        ENET_PROTOCOL_COMMAND_DISCONNECT               = 4,
+        ENET_PROTOCOL_COMMAND_PING                     = 5,
+        ENET_PROTOCOL_COMMAND_SEND_RELIABLE            = 6,
+        ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE          = 7,
+        ENET_PROTOCOL_COMMAND_SEND_FRAGMENT            = 8,
+        ENET_PROTOCOL_COMMAND_SEND_UNSEQUENCED         = 9,
+        ENET_PROTOCOL_COMMAND_BANDWIDTH_LIMIT          = 10,
+        ENET_PROTOCOL_COMMAND_THROTTLE_CONFIGURE       = 11,
+        ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE_FRAGMENT = 12,
+        ENET_PROTOCOL_COMMAND_COUNT                    = 13,
+        ENET_PROTOCOL_COMMAND_MASK                     = 0x0F
+    } ENetProtocolCommand;
+
+    typedef enum _ENetProtocolFlag {
+        ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE = (1 << 7),
+        ENET_PROTOCOL_COMMAND_FLAG_UNSEQUENCED = (1 << 6),
+        ENET_PROTOCOL_HEADER_FLAG_SENT_TIME    = (1 << 14),
+        ENET_PROTOCOL_HEADER_FLAG_MASK         = ENET_PROTOCOL_HEADER_FLAG_SENT_TIME,
+        ENET_PROTOCOL_HEADER_SESSION_MASK      = (3 << 12),
+        ENET_PROTOCOL_HEADER_SESSION_SHIFT     = 12
+    } ENetProtocolFlag;
+
+    #ifdef _MSC_VER
+        #pragma pack(push, 1)
+        #define ENET_PACKED
+    #elif defined(__GNUC__) || defined(__clang__)
+        #define ENET_PACKED __attribute__ ((packed))
+    #else
+        #define ENET_PACKED
+    #endif
+
+    typedef struct _ENetProtocolHeader {
+        enet_uint16 peerID;
+        enet_uint16 sentTime;
+    } ENET_PACKED ENetProtocolHeader;
+
+    typedef struct _ENetProtocolCommandHeader {
+        enet_uint8  command;
+        enet_uint8  channelID;
+        enet_uint16 reliableSequenceNumber;
+    } ENET_PACKED ENetProtocolCommandHeader;
+
+    typedef struct _ENetProtocolAcknowledge {
+        ENetProtocolCommandHeader header;
+        enet_uint16               receivedReliableSequenceNumber;
+        enet_uint16               receivedSentTime;
+    } ENET_PACKED ENetProtocolAcknowledge;
+
+    typedef struct _ENetProtocolConnect {
+        ENetProtocolCommandHeader header;
+        enet_uint16               outgoingPeerID;
+        enet_uint8                incomingSessionID;
+        enet_uint8                outgoingSessionID;
+        enet_uint32               mtu;
+        enet_uint32               windowSize;
+        enet_uint32               channelCount;
+        enet_uint32               incomingBandwidth;
+        enet_uint32               outgoingBandwidth;
+        enet_uint32               packetThrottleInterval;
+        enet_uint32               packetThrottleAcceleration;
+        enet_uint32               packetThrottleDeceleration;
+        enet_uint32               connectID;
+        enet_uint32               data;
+    } ENET_PACKED ENetProtocolConnect;
+
+    typedef struct _ENetProtocolVerifyConnect {
+        ENetProtocolCommandHeader header;
+        enet_uint16               outgoingPeerID;
+        enet_uint8                incomingSessionID;
+        enet_uint8                outgoingSessionID;
+        enet_uint32               mtu;
+        enet_uint32               windowSize;
+        enet_uint32               channelCount;
+        enet_uint32               incomingBandwidth;
+        enet_uint32               outgoingBandwidth;
+        enet_uint32               packetThrottleInterval;
+        enet_uint32               packetThrottleAcceleration;
+        enet_uint32               packetThrottleDeceleration;
+        enet_uint32               connectID;
+    } ENET_PACKED ENetProtocolVerifyConnect;
+
+    typedef struct _ENetProtocolBandwidthLimit {
+        ENetProtocolCommandHeader header;
+        enet_uint32               incomingBandwidth;
+        enet_uint32               outgoingBandwidth;
+    } ENET_PACKED ENetProtocolBandwidthLimit;
+
+    typedef struct _ENetProtocolThrottleConfigure {
+        ENetProtocolCommandHeader header;
+        enet_uint32               packetThrottleInterval;
+        enet_uint32               packetThrottleAcceleration;
+        enet_uint32               packetThrottleDeceleration;
+    } ENET_PACKED ENetProtocolThrottleConfigure;
+
+    typedef struct _ENetProtocolDisconnect {
+        ENetProtocolCommandHeader header;
+        enet_uint32               data;
+    } ENET_PACKED ENetProtocolDisconnect;
+
+    typedef struct _ENetProtocolPing {
+        ENetProtocolCommandHeader header;
+    } ENET_PACKED ENetProtocolPing;
+
+    typedef struct _ENetProtocolSendReliable {
+        ENetProtocolCommandHeader header;
+        enet_uint16               dataLength;
+    } ENET_PACKED ENetProtocolSendReliable;
+
+    typedef struct _ENetProtocolSendUnreliable {
+        ENetProtocolCommandHeader header;
+        enet_uint16               unreliableSequenceNumber;
+        enet_uint16               dataLength;
+    } ENET_PACKED ENetProtocolSendUnreliable;
+
+    typedef struct _ENetProtocolSendUnsequenced {
+        ENetProtocolCommandHeader header;
+        enet_uint16               unsequencedGroup;
+        enet_uint16               dataLength;
+    } ENET_PACKED ENetProtocolSendUnsequenced;
+
+    typedef struct _ENetProtocolSendFragment {
+        ENetProtocolCommandHeader header;
+        enet_uint16               startSequenceNumber;
+        enet_uint16               dataLength;
+        enet_uint32               fragmentCount;
+        enet_uint32               fragmentNumber;
+        enet_uint32               totalLength;
+        enet_uint32               fragmentOffset;
+    } ENET_PACKED ENetProtocolSendFragment;
+
+    typedef union _ENetProtocol {
+        ENetProtocolCommandHeader     header;
+        ENetProtocolAcknowledge       acknowledge;
+        ENetProtocolConnect           connect;
+        ENetProtocolVerifyConnect     verifyConnect;
+        ENetProtocolDisconnect        disconnect;
+        ENetProtocolPing              ping;
+        ENetProtocolSendReliable      sendReliable;
+        ENetProtocolSendUnreliable    sendUnreliable;
+        ENetProtocolSendUnsequenced   sendUnsequenced;
+        ENetProtocolSendFragment      sendFragment;
+        ENetProtocolBandwidthLimit    bandwidthLimit;
+        ENetProtocolThrottleConfigure throttleConfigure;
+    } ENET_PACKED ENetProtocol;
+
+    #ifdef _MSC_VER
+        #pragma pack(pop)
+    #endif
+
+// =======================================================================//
+// !
+// ! General ENet structs/enums
+// !
+// =======================================================================//
+
+    typedef enum _ENetSocketType {
+        ENET_SOCKET_TYPE_STREAM   = 1,
+        ENET_SOCKET_TYPE_DATAGRAM = 2
+    } ENetSocketType;
+
+    typedef enum _ENetSocketWait {
+        ENET_SOCKET_WAIT_NONE      = 0,
+        ENET_SOCKET_WAIT_SEND      = (1 << 0),
+        ENET_SOCKET_WAIT_RECEIVE   = (1 << 1),
+        ENET_SOCKET_WAIT_INTERRUPT = (1 << 2)
+    } ENetSocketWait;
+
+    typedef enum _ENetSocketOption {
+        ENET_SOCKOPT_NONBLOCK  = 1,
+        ENET_SOCKOPT_BROADCAST = 2,
+        ENET_SOCKOPT_RCVBUF    = 3,
+        ENET_SOCKOPT_SNDBUF    = 4,
+        ENET_SOCKOPT_REUSEADDR = 5,
+        ENET_SOCKOPT_RCVTIMEO  = 6,
+        ENET_SOCKOPT_SNDTIMEO  = 7,
+        ENET_SOCKOPT_ERROR     = 8,
+        ENET_SOCKOPT_NODELAY   = 9,
+        ENET_SOCKOPT_IPV6_V6ONLY = 10,
+    } ENetSocketOption;
+
+    typedef enum _ENetSocketShutdown {
+        ENET_SOCKET_SHUTDOWN_READ       = 0,
+        ENET_SOCKET_SHUTDOWN_WRITE      = 1,
+        ENET_SOCKET_SHUTDOWN_READ_WRITE = 2
+    } ENetSocketShutdown;
+
+    typedef struct _ENetAddress {
+        struct in6_addr host;
+        enet_uint16 port;
+        enet_uint16 sin6_scope_id;
+    } ENetAddress;
+
+    #define in6_equal(in6_addr_a, in6_addr_b) (memcmp(&in6_addr_a, &in6_addr_b, sizeof(struct in6_addr)) == 0)
+
+    typedef enum _ENetPacketFlag {
+        ENET_PACKET_FLAG_RELIABLE            = (1 << 0),
+        ENET_PACKET_FLAG_UNSEQUENCED         = (1 << 1),
+        ENET_PACKET_FLAG_NO_ALLOCATE         = (1 << 2),
+        ENET_PACKET_FLAG_UNRELIABLE_FRAGMENT = (1 << 3),
+        ENET_PACKET_FLAG_SENT                = (1 << 8),
+    } ENetPacketFlag;
+
+    typedef void (ENET_CALLBACK *ENetPacketFreeCallback) (void *);
+
+    typedef struct _ENetPacket {
+        size_t                 referenceCount;
+        enet_uint32            flags;
+        enet_uint8 *           data;
+        size_t                 dataLength;
+        ENetPacketFreeCallback freeCallback;
+        void *                 userData;
+    } ENetPacket;
+
+    typedef struct _ENetAcknowledgement {
+        ENetListNode acknowledgementList;
+        enet_uint32  sentTime;
+        ENetProtocol command;
+    } ENetAcknowledgement;
+
+    typedef struct _ENetOutgoingCommand {
+        ENetListNode outgoingCommandList;
+        enet_uint16  reliableSequenceNumber;
+        enet_uint16  unreliableSequenceNumber;
+        enet_uint32  sentTime;
+        enet_uint32  roundTripTimeout;
+        enet_uint32  roundTripTimeoutLimit;
+        enet_uint32  fragmentOffset;
+        enet_uint16  fragmentLength;
+        enet_uint16  sendAttempts;
+        ENetProtocol command;
+        ENetPacket * packet;
+    } ENetOutgoingCommand;
+
+    typedef struct _ENetIncomingCommand {
+        ENetListNode incomingCommandList;
+        enet_uint16  reliableSequenceNumber;
+        enet_uint16  unreliableSequenceNumber;
+        ENetProtocol command;
+        enet_uint32  fragmentCount;
+        enet_uint32  fragmentsRemaining;
+        enet_uint32 *fragments;
+        ENetPacket * packet;
+    } ENetIncomingCommand;
+
+    typedef enum _ENetPeerState {
+        ENET_PEER_STATE_DISCONNECTED             = 0,
+        ENET_PEER_STATE_CONNECTING               = 1,
+        ENET_PEER_STATE_ACKNOWLEDGING_CONNECT    = 2,
+        ENET_PEER_STATE_CONNECTION_PENDING       = 3,
+        ENET_PEER_STATE_CONNECTION_SUCCEEDED     = 4,
+        ENET_PEER_STATE_CONNECTED                = 5,
+        ENET_PEER_STATE_DISCONNECT_LATER         = 6,
+        ENET_PEER_STATE_DISCONNECTING            = 7,
+        ENET_PEER_STATE_ACKNOWLEDGING_DISCONNECT = 8,
+        ENET_PEER_STATE_ZOMBIE                   = 9
+    } ENetPeerState;
+
+    enum {
+        ENET_HOST_RECEIVE_BUFFER_SIZE          = 256 * 1024,
+        ENET_HOST_SEND_BUFFER_SIZE             = 256 * 1024,
+        ENET_HOST_BANDWIDTH_THROTTLE_INTERVAL  = 1000,
+        ENET_HOST_DEFAULT_MTU                  = 1400,
+        ENET_HOST_DEFAULT_MAXIMUM_PACKET_SIZE  = 32 * 1024 * 1024,
+        ENET_HOST_DEFAULT_MAXIMUM_WAITING_DATA = 32 * 1024 * 1024,
+        ENET_PEER_DEFAULT_ROUND_TRIP_TIME      = 500,
+        ENET_PEER_DEFAULT_PACKET_THROTTLE      = 32,
+        ENET_PEER_PACKET_THROTTLE_SCALE        = 32,
+        ENET_PEER_PACKET_THROTTLE_COUNTER      = 7,
+        ENET_PEER_PACKET_THROTTLE_ACCELERATION = 2,
+        ENET_PEER_PACKET_THROTTLE_DECELERATION = 2,
+        ENET_PEER_PACKET_THROTTLE_INTERVAL     = 5000,
+        ENET_PEER_PACKET_LOSS_SCALE            = (1 << 16),
+        ENET_PEER_PACKET_LOSS_INTERVAL         = 10000,
+        ENET_PEER_WINDOW_SIZE_SCALE            = 64 * 1024,
+        ENET_PEER_TIMEOUT_LIMIT                = 32,
+        ENET_PEER_TIMEOUT_MINIMUM              = 5000,
+        ENET_PEER_TIMEOUT_MAXIMUM              = 30000,
+        ENET_PEER_PING_INTERVAL                = 500,
+        ENET_PEER_UNSEQUENCED_WINDOWS          = 64,
+        ENET_PEER_UNSEQUENCED_WINDOW_SIZE      = 1024,
+        ENET_PEER_FREE_UNSEQUENCED_WINDOWS     = 32,
+        ENET_PEER_RELIABLE_WINDOWS             = 16,
+        ENET_PEER_RELIABLE_WINDOW_SIZE         = 0x1000,
+        ENET_PEER_FREE_RELIABLE_WINDOWS        = 8
+    };
+
+    typedef struct _ENetChannel {
+        enet_uint16 outgoingReliableSequenceNumber;
+        enet_uint16 outgoingUnreliableSequenceNumber;
+        enet_uint16 usedReliableWindows;
+        enet_uint16 reliableWindows[ENET_PEER_RELIABLE_WINDOWS];
+        enet_uint16 incomingReliableSequenceNumber;
+        enet_uint16 incomingUnreliableSequenceNumber;
+        ENetList    incomingReliableCommands;
+        ENetList    incomingUnreliableCommands;
+    } ENetChannel;
+
+    typedef struct _ENetPeer {
+        ENetListNode      dispatchList;
+        struct _ENetHost *host;
+        enet_uint16       outgoingPeerID;
+        enet_uint16       incomingPeerID;
+        enet_uint32       connectID;
+        enet_uint8        outgoingSessionID;
+        enet_uint8        incomingSessionID;
+        ENetAddress       address;
+        void *            data;
+        ENetPeerState     state;
+        ENetChannel *     channels;
+        size_t            channelCount;
+        enet_uint32       incomingBandwidth;
+        enet_uint32       outgoingBandwidth;
+        enet_uint32       incomingBandwidthThrottleEpoch;
+        enet_uint32       outgoingBandwidthThrottleEpoch;
+        enet_uint32       incomingDataTotal;
+        enet_uint64       totalDataReceived;
+        enet_uint32       outgoingDataTotal;
+        enet_uint64       totalDataSent;
+        enet_uint32       lastSendTime;
+        enet_uint32       lastReceiveTime;
+        enet_uint32       nextTimeout;
+        enet_uint32       earliestTimeout;
+        enet_uint32       packetLossEpoch;
+        enet_uint32       packetsSent;
+        enet_uint64       totalPacketsSent;
+        enet_uint32       packetsLost;
+        enet_uint32       totalPacketsLost;
+        enet_uint32       packetLoss;
+        enet_uint32       packetLossVariance;
+        enet_uint32       packetThrottle;
+        enet_uint32       packetThrottleLimit;
+        enet_uint32       packetThrottleCounter;
+        enet_uint32       packetThrottleEpoch;
+        enet_uint32       packetThrottleAcceleration;
+        enet_uint32       packetThrottleDeceleration;
+        enet_uint32       packetThrottleInterval;
+        enet_uint32       pingInterval;
+        enet_uint32       timeoutLimit;
+        enet_uint32       timeoutMinimum;
+        enet_uint32       timeoutMaximum;
+        enet_uint32       lastRoundTripTime;
+        enet_uint32       lowestRoundTripTime;
+        enet_uint32       lastRoundTripTimeVariance;
+        enet_uint32       highestRoundTripTimeVariance;
+        enet_uint32       roundTripTime;
+        enet_uint32       roundTripTimeVariance;
+        enet_uint32       mtu;
+        enet_uint32       windowSize;
+        enet_uint32       reliableDataInTransit;
+        enet_uint16       outgoingReliableSequenceNumber;
+        ENetList          acknowledgements;
+        ENetList          sentReliableCommands;
+        ENetList          sentUnreliableCommands;
+        ENetList          outgoingReliableCommands;
+        ENetList          outgoingUnreliableCommands;
+        ENetList          dispatchedCommands;
+        int               needsDispatch;
+        enet_uint16       incomingUnsequencedGroup;
+        enet_uint16       outgoingUnsequencedGroup;
+        enet_uint32       unsequencedWindow[ENET_PEER_UNSEQUENCED_WINDOW_SIZE / 32];
+        enet_uint32       eventData;
+        size_t            totalWaitingData;
+    } ENetPeer;
+
+    typedef enet_uint32 (ENET_CALLBACK * ENetChecksumCallback) (const ENetBuffer *buffers, size_t bufferCount);
+
+    typedef int (ENET_CALLBACK * ENetInterceptCallback) (struct _ENetHost *host, void *event);
+
+    typedef struct _ENetHost {
+        ENetSocket            socket;
+        ENetAddress           address;
+        enet_uint32           incomingBandwidth;
+        enet_uint32           outgoingBandwidth;
+        enet_uint32           bandwidthThrottleEpoch;
+        enet_uint32           mtu;
+        enet_uint32           randomSeed;
+        int                   recalculateBandwidthLimits;
+        ENetPeer *            peers;
+        size_t                peerCount;
+        size_t                channelLimit;
+        enet_uint32           serviceTime;
+        ENetList              dispatchQueue;
+        int                   continueSending;
+        size_t                packetSize;
+        enet_uint16           headerFlags;
+        enet_uint32           totalSentData;
+        enet_uint32           totalSentPackets;
+        enet_uint32           totalReceivedData;
+        enet_uint32           totalReceivedPackets;
+        ENetProtocol          commands[ENET_PROTOCOL_MAXIMUM_PACKET_COMMANDS];
+        size_t                commandCount;
+        ENetBuffer            buffers[ENET_BUFFER_MAXIMUM];
+        size_t                bufferCount;
+        ENetChecksumCallback  checksum;
+        enet_uint8            packetData[2][ENET_PROTOCOL_MAXIMUM_MTU];
+        ENetAddress           receivedAddress;
+        enet_uint8 *          receivedData;
+        size_t                receivedDataLength;
+        ENetInterceptCallback interceptCallback;
+        size_t                connectedPeers;
+        size_t                bandwidthLimitedPeers;
+        size_t                duplicatePeers;
+        size_t                maximumPacketSize;
+        size_t                maximumWaitingData;
+    } ENetHost;
+
+    typedef enum _ENetEventType {
+        ENET_EVENT_TYPE_NONE       = 0,
+        ENET_EVENT_TYPE_CONNECT    = 1,
+        ENET_EVENT_TYPE_DISCONNECT = 2,
+        ENET_EVENT_TYPE_RECEIVE    = 3,
+        ENET_EVENT_TYPE_DISCONNECT_TIMEOUT = 4,
+    } ENetEventType;
+
+    typedef struct _ENetEvent {
+        ENetEventType type;
+        ENetPeer *    peer;
+        enet_uint8    channelID;
+        enet_uint32   data;
+        ENetPacket *  packet;
+    } ENetEvent;
+
+// =======================================================================//
+// !
+// ! Public API
+// !
+// =======================================================================//
+
+    ENET_API int                 enet_initialize (void);
+    ENET_API int                 enet_initialize_with_callbacks (ENetVersion version, const ENetCallbacks * inits);
+    ENET_API void                enet_deinitialize (void);
+    ENET_API ENetVersion         enet_linked_version (void);
+    ENET_API enet_uint32         enet_time_get (void);
+
+    ENET_API ENetSocket          enet_socket_create(ENetSocketType);
+    ENET_API int                 enet_socket_bind(ENetSocket, const ENetAddress *);
+    ENET_API int                 enet_socket_get_address(ENetSocket, ENetAddress *);
+    ENET_API int                 enet_socket_listen(ENetSocket, int);
+    ENET_API ENetSocket          enet_socket_accept(ENetSocket, ENetAddress *);
+    ENET_API int                 enet_socket_connect(ENetSocket, const ENetAddress *);
+    ENET_API int                 enet_socket_send(ENetSocket, const ENetAddress *, const ENetBuffer *, size_t);
+    ENET_API int                 enet_socket_receive(ENetSocket, ENetAddress *, ENetBuffer *, size_t);
+    ENET_API int                 enet_socket_wait(ENetSocket, enet_uint32 *, enet_uint64);
+    ENET_API int                 enet_socket_set_option(ENetSocket, ENetSocketOption, int);
+    ENET_API int                 enet_socket_get_option(ENetSocket, ENetSocketOption, int *);
+    ENET_API int                 enet_socket_shutdown(ENetSocket, ENetSocketShutdown);
+    ENET_API void                enet_socket_destroy(ENetSocket);
+    ENET_API int                 enet_socketset_select(ENetSocket, ENetSocketSet *, ENetSocketSet *, enet_uint32);
+
+    ENET_API int                 enet_address_set_host_ip (ENetAddress * address, const char * hostName);
+    ENET_API int                 enet_address_set_host (ENetAddress * address, const char * hostName);
+    ENET_API int                 enet_address_get_host_ip (const ENetAddress * address, char * hostName, size_t nameLength);
+    ENET_API int                 enet_address_get_host (const ENetAddress * address, char * hostName, size_t nameLength);
+
+    ENET_API ENetPacket *        enet_packet_create (const void *, size_t, enet_uint32);
+    ENET_API ENetPacket *        enet_packet_create_offset (const void *, size_t, size_t, enet_uint32);
+    ENET_API void                enet_packet_destroy (ENetPacket *);
+
+    ENET_API enet_uint32         enet_crc32 (const ENetBuffer *, size_t);
+
+    ENET_API ENetHost *          enet_host_create (const ENetAddress *, size_t, size_t, enet_uint32, enet_uint32);
+    ENET_API void                enet_host_destroy (ENetHost *);
+    ENET_API ENetPeer *          enet_host_connect (ENetHost *, const ENetAddress *, size_t, enet_uint32);
+    ENET_API int                 enet_host_check_events (ENetHost *, ENetEvent *);
+    ENET_API int                 enet_host_service (ENetHost *, ENetEvent *, enet_uint32);
+    ENET_API void                enet_host_flush (ENetHost *);
+    ENET_API void                enet_host_broadcast (ENetHost *, enet_uint8, ENetPacket *);
+    ENET_API void                enet_host_channel_limit (ENetHost *, size_t);
+    ENET_API void                enet_host_bandwidth_limit (ENetHost *, enet_uint32, enet_uint32);
+    extern   void                enet_host_bandwidth_throttle (ENetHost *);
+    extern  enet_uint64          enet_host_random_seed (void);
+
+    ENET_API int                 enet_peer_send (ENetPeer *, enet_uint8, ENetPacket *);
+    ENET_API ENetPacket *        enet_peer_receive (ENetPeer *, enet_uint8 * channelID);
+    ENET_API void                enet_peer_ping (ENetPeer *);
+    ENET_API void                enet_peer_ping_interval (ENetPeer *, enet_uint32);
+    ENET_API void                enet_peer_timeout (ENetPeer *, enet_uint32, enet_uint32, enet_uint32);
+    ENET_API void                enet_peer_reset (ENetPeer *);
+    ENET_API void                enet_peer_disconnect (ENetPeer *, enet_uint32);
+    ENET_API void                enet_peer_disconnect_now (ENetPeer *, enet_uint32);
+    ENET_API void                enet_peer_disconnect_later (ENetPeer *, enet_uint32);
+    ENET_API void                enet_peer_throttle_configure (ENetPeer *, enet_uint32, enet_uint32, enet_uint32);
+    extern int                   enet_peer_throttle (ENetPeer *, enet_uint32);
+    extern void                  enet_peer_reset_queues (ENetPeer *);
+    extern void                  enet_peer_setup_outgoing_command (ENetPeer *, ENetOutgoingCommand *);
+    extern ENetOutgoingCommand * enet_peer_queue_outgoing_command (ENetPeer *, const ENetProtocol *, ENetPacket *, enet_uint32, enet_uint16);
+    extern ENetIncomingCommand * enet_peer_queue_incoming_command (ENetPeer *, const ENetProtocol *, const void *, size_t, enet_uint32, enet_uint32);
+    extern ENetAcknowledgement * enet_peer_queue_acknowledgement (ENetPeer *, const ENetProtocol *, enet_uint16);
+    extern void                  enet_peer_dispatch_incoming_unreliable_commands (ENetPeer *, ENetChannel *);
+    extern void                  enet_peer_dispatch_incoming_reliable_commands (ENetPeer *, ENetChannel *);
+    extern void                  enet_peer_on_connect (ENetPeer *);
+    extern void                  enet_peer_on_disconnect (ENetPeer *);
+
+    extern size_t                enet_protocol_command_size (enet_uint8);
+
+    /* Extended API for easier binding in other programming languages */
+    ENET_API void *              enet_packet_get_data (ENetPacket *);
+    ENET_API int                 enet_packet_get_length (ENetPacket *);
+    ENET_API void                enet_packet_set_free_callback (ENetPacket *, const void *);
+    ENET_API void                enet_packet_dispose (ENetPacket *);
+
+    ENET_API enet_uint32         enet_host_get_peers_count (ENetHost *);
+    ENET_API enet_uint32         enet_host_get_packets_sent (ENetHost *);
+    ENET_API enet_uint32         enet_host_get_packets_received (ENetHost *);
+    ENET_API enet_uint32         enet_host_get_bytes_sent (ENetHost *);
+    ENET_API enet_uint32         enet_host_get_bytes_received (ENetHost *);
+
+    ENET_API enet_uint32         enet_peer_get_id (ENetPeer *);
+    ENET_API int                 enet_peer_get_ip (ENetPeer *, char * ip, size_t ipLength);
+    ENET_API enet_uint16         enet_peer_get_port (ENetPeer *);
+    ENET_API ENetPeerState       enet_peer_get_state (ENetPeer *);
+    ENET_API enet_uint32         enet_peer_get_rtt (ENetPeer *);
+    ENET_API enet_uint64         enet_peer_get_packets_sent (ENetPeer *);
+    ENET_API enet_uint32         enet_peer_get_packets_lost (ENetPeer *);
+    ENET_API enet_uint64         enet_peer_get_bytes_sent (ENetPeer *);
+    ENET_API enet_uint64         enet_peer_get_bytes_received (ENetPeer *);
+    ENET_API void *              enet_peer_get_data (ENetPeer *);
+    ENET_API void                enet_peer_set_data (ENetPeer *, const void *);
+
+#ifdef __cplusplus
+}
+#endif
+
+#if defined(ENET_IMPLEMENTATION) && !defined(ENET_IMPLEMENTATION_DONE)
+#define ENET_IMPLEMENTATION_DONE 1
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// =======================================================================//
+// !
+// ! Atomics
+// !
+// =======================================================================//
+
+#if defined(_MSC_VER)
+    #define ENET_AT_CASSERT_PRED(predicate) sizeof(char[2 * !!(predicate)-1])
+    #define ENET_IS_SUPPORTED_ATOMIC(size) ENET_AT_CASSERT_PRED(size == 1 || size == 2 || size == 4 || size == 8)
+    #define ENET_ATOMIC_SIZEOF(variable) (ENET_IS_SUPPORTED_ATOMIC(sizeof(*(variable))), sizeof(*(variable)))
+
+    __inline int64_t enet_at_atomic_read(char *ptr, size_t size) {
+        switch (size) {
+            case 1:
+                return _InterlockedExchangeAdd8((volatile char *)ptr, 0);
+
+            case 2:
+                return _InterlockedExchangeAdd16((volatile SHORT *)ptr, 0);
+
+            case 4:
+                #ifdef NOT_UNDERSCORED_INTERLOCKED_EXCHANGE
+                    return InterlockedExchangeAdd((volatile LONG *)ptr, 0);
+                #else
+                    return _InterlockedExchangeAdd((volatile LONG *)ptr, 0);
+                #endif
+
+            case 8:
+                #ifdef NOT_UNDERSCORED_INTERLOCKED_EXCHANGE
+                    return InterlockedExchangeAdd64((volatile LONGLONG *)ptr, 0);
+                #else
+                    return _InterlockedExchangeAdd64((volatile LONGLONG *)ptr, 0);
+                #endif
+
+            default:
+                return 0x0;
+        }
+    }
+
+    __inline int64_t enet_at_atomic_write(char *ptr, int64_t value, size_t size) {
+        switch (size) {
+            case 1:
+                return _InterlockedExchange8((volatile char *)ptr, (char)value);
+
+            case 2:
+                return _InterlockedExchange16((volatile SHORT *)ptr, (SHORT)value);
+
+            case 4:
+                #ifdef NOT_UNDERSCORED_INTERLOCKED_EXCHANGE
+                    return InterlockedExchange((volatile LONG *)ptr, (LONG)value);
+                #else
+                    return _InterlockedExchange((volatile LONG *)ptr, (LONG)value);
+                #endif
+
+            case 8:
+                #ifdef NOT_UNDERSCORED_INTERLOCKED_EXCHANGE
+                    return InterlockedExchange64((volatile LONGLONG *)ptr, (LONGLONG)value);
+                #else
+                    return _InterlockedExchange64((volatile LONGLONG *)ptr, (LONGLONG)value);
+                #endif
+
+            default:
+                return 0x0;
+        }
+    }
+
+    __inline int64_t enet_at_atomic_cas(char *ptr, int64_t new_val, int64_t old_val, size_t size) {
+        switch (size) {
+            case 1:
+                return _InterlockedCompareExchange8((volatile char *)ptr, (char)new_val, (char)old_val);
+
+            case 2:
+                return _InterlockedCompareExchange16((volatile SHORT *)ptr, (SHORT)new_val,
+                                                     (SHORT)old_val);
+            case 4:
+                #ifdef NOT_UNDERSCORED_INTERLOCKED_EXCHANGE
+                    return InterlockedCompareExchange((volatile LONG *)ptr, (LONG)new_val, (LONG)old_val);
+                #else
+                    return _InterlockedCompareExchange((volatile LONG *)ptr, (LONG)new_val, (LONG)old_val);
+                #endif
+
+            case 8:
+                #ifdef NOT_UNDERSCORED_INTERLOCKED_EXCHANGE
+                    return InterlockedCompareExchange64((volatile LONGLONG *)ptr, (LONGLONG)new_val, (LONGLONG)old_val);
+                #else
+                    return _InterlockedCompareExchange64((volatile LONGLONG *)ptr, (LONGLONG)new_val, (LONGLONG)old_val);
+                #endif
+
+            default:
+                return 0x0;
+        }
+    }
+
+    __inline int64_t enet_at_atomic_inc(char *ptr, int64_t delta, size_t data_size) {
+        switch (data_size) {
+            case 1:
+                return _InterlockedExchangeAdd8((volatile char *)ptr, (char)delta);
+
+            case 2:
+                return _InterlockedExchangeAdd16((volatile SHORT *)ptr, (SHORT)delta);
+
+            case 4:
+                #ifdef NOT_UNDERSCORED_INTERLOCKED_EXCHANGE
+                    return InterlockedExchangeAdd((volatile LONG *)ptr, (LONG)delta);
+                #else
+                    return _InterlockedExchangeAdd((volatile LONG *)ptr, (LONG)delta);
+                #endif
+
+            case 8:
+                #ifdef NOT_UNDERSCORED_INTERLOCKED_EXCHANGE
+                    return InterlockedExchangeAdd64((volatile LONGLONG *)ptr, (LONGLONG)delta);
+                #else
+                    return _InterlockedExchangeAdd64((volatile LONGLONG *)ptr, (LONGLONG)delta);
+                #endif
+
+            default:
+                return 0x0;
+        }
+    }
+
+    #define ENET_ATOMIC_READ(variable) enet_at_atomic_read((char *) (variable), ENET_ATOMIC_SIZEOF(variable))
+    #define ENET_ATOMIC_WRITE(variable, new_val)                                                                 \
+        enet_at_atomic_write((char *) (variable), (int64_t) (new_val), ENET_ATOMIC_SIZEOF(variable))
+    #define ENET_ATOMIC_CAS(variable, old_value, new_val)                                                        \
+        enet_at_atomic_cas((char *) (variable), (int64_t) (new_val), (int64_t) (old_value),                         \
+                      ENET_ATOMIC_SIZEOF(variable))
+    #define ENET_ATOMIC_INC(variable) enet_at_atomic_inc((char *) (variable), 1, ENET_ATOMIC_SIZEOF(variable))
+    #define ENET_ATOMIC_DEC(variable) enet_at_atomic_inc((char *) (variable), -1, ENET_ATOMIC_SIZEOF(variable))
+    #define ENET_ATOMIC_INC_BY(variable, delta)                                                                  \
+        enet_at_atomic_inc((char *) (variable), (delta), ENET_ATOMIC_SIZEOF(variable))
+    #define ENET_ATOMIC_DEC_BY(variable, delta)                                                                  \
+        enet_at_atomic_inc((char *) (variable), -(delta), ENET_ATOMIC_SIZEOF(variable))
+#elif defined(__GNUC__) || defined(__clang__)
+    #if defined(__clang__) || (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7))
+        #define AT_HAVE_ATOMICS
+    #endif
+
+    /* We want to use __atomic built-ins if possible because the __sync primitives are
+       deprecated, because the __atomic build-ins allow us to use ENET_ATOMIC_WRITE on
+       uninitialized memory without running into undefined behavior, and because the
+       __atomic versions generate more efficient code since we don't need to rely on
+       CAS when we don't actually want it.
+
+       Note that we use acquire-release memory order (like mutexes do). We could use
+       sequentially consistent memory order but that has lower performance and is
+       almost always unneeded. */
+    #ifdef AT_HAVE_ATOMICS
+        #define ENET_ATOMIC_READ(ptr) __atomic_load_n((ptr), __ATOMIC_ACQUIRE)
+        #define ENET_ATOMIC_WRITE(ptr, value) __atomic_store_n((ptr), (value), __ATOMIC_RELEASE)
+
+        #ifndef typeof
+            #define typeof __typeof__
+        #endif
+
+        /* clang_analyzer doesn't know that CAS writes to memory so it complains about
+           potentially lost data. Replace the code with the equivalent non-sync code. */
+        #ifdef __clang_analyzer__
+            #define ENET_ATOMIC_CAS(ptr, old_value, new_value)                                                      \
+                ({                                                                                                  \
+                    typeof(*(ptr)) ENET_ATOMIC_CAS_old_actual_ = (*(ptr));                                          \
+                    if (ATOMIC_CAS_old_actual_ == (old_value)) {                                                    \
+                        *(ptr) = new_value;                                                                         \
+                    }                                                                                               \
+                    ENET_ATOMIC_CAS_old_actual_;                                                                    \
+                })
+            #else
+            /* Could use __auto_type instead of typeof but that shouldn't work in C++.
+               The ({ }) syntax is a GCC extension called statement expression. It lets
+               us return a value out of the macro.
+
+               TODO We should return bool here instead of the old value to avoid the ABA
+               problem. */
+            #define ENET_ATOMIC_CAS(ptr, old_value, new_value)                                                      \
+                ({                                                                                                  \
+                    typeof(*(ptr)) ENET_ATOMIC_CAS_expected_ = (old_value);                                         \
+                    __atomic_compare_exchange_n((ptr), &ENET_ATOMIC_CAS_expected_, (new_value), false,              \
+                                                __ATOMIC_ACQ_REL, __ATOMIC_ACQUIRE);                                \
+                    ENET_ATOMIC_CAS_expected_;                                                                      \
+                })
+            #endif
+
+            #define ENET_ATOMIC_INC(ptr) __atomic_fetch_add((ptr), 1, __ATOMIC_ACQ_REL)
+            #define ENET_ATOMIC_DEC(ptr) __atomic_fetch_sub((ptr), 1, __ATOMIC_ACQ_REL)
+            #define ENET_ATOMIC_INC_BY(ptr, delta) __atomic_fetch_add((ptr), (delta), __ATOMIC_ACQ_REL)
+            #define ENET_ATOMIC_DEC_BY(ptr, delta) __atomic_fetch_sub((ptr), (delta), __ATOMIC_ACQ_REL)
+        #else
+            #define ENET_ATOMIC_READ(variable) __sync_fetch_and_add(variable, 0)
+            #define ENET_ATOMIC_WRITE(variable, new_val)                                                            \
+                (void) __sync_val_compare_and_swap((variable), *(variable), (new_val))
+            #define ENET_ATOMIC_CAS(variable, old_value, new_val)                                                   \
+                __sync_val_compare_and_swap((variable), (old_value), (new_val))
+            #define ENET_ATOMIC_INC(variable) __sync_fetch_and_add((variable), 1)
+            #define ENET_ATOMIC_DEC(variable) __sync_fetch_and_sub((variable), 1)
+            #define ENET_ATOMIC_INC_BY(variable, delta) __sync_fetch_and_add((variable), (delta), 1)
+            #define ENET_ATOMIC_DEC_BY(variable, delta) __sync_fetch_and_sub((variable), (delta), 1)
+    #endif
+    #undef AT_HAVE_ATOMICS
+#endif
+
+// =======================================================================//
+// !
+// ! Callbacks
+// !
+// =======================================================================//
+
+    static ENetCallbacks callbacks = { malloc, free, abort };
+
+    int enet_initialize_with_callbacks(ENetVersion version, const ENetCallbacks *inits) {
+        if (version < ENET_VERSION_CREATE(1, 3, 0)) {
+            return -1;
+        }
+
+        if (inits->malloc != NULL || inits->free != NULL) {
+            if (inits->malloc == NULL || inits->free == NULL) {
+                return -1;
+            }
+
+            callbacks.malloc = inits->malloc;
+            callbacks.free   = inits->free;
+        }
+
+        if (inits->no_memory != NULL) {
+            callbacks.no_memory = inits->no_memory;
+        }
+
+        return enet_initialize();
+    }
+
+    ENetVersion enet_linked_version(void) {
+        return ENET_VERSION;
+    }
+
+    void *enet_malloc(size_t size) {
+        void *memory = callbacks.malloc(size);
+
+        if (memory == NULL) {
+            callbacks.no_memory();
+        }
+
+        return memory;
+    }
+
+    void enet_free(void *memory) {
+        callbacks.free(memory);
+    }
+
+// =======================================================================//
+// !
+// ! List
+// !
+// =======================================================================//
+
+    void enet_list_clear(ENetList *list) {
+        list->sentinel.next     = &list->sentinel;
+        list->sentinel.previous = &list->sentinel;
+    }
+
+    ENetListIterator enet_list_insert(ENetListIterator position, void *data) {
+        ENetListIterator result = (ENetListIterator)data;
+
+        result->previous = position->previous;
+        result->next     = position;
+
+        result->previous->next = result;
+        position->previous     = result;
+
+        return result;
+    }
+
+    void *enet_list_remove(ENetListIterator position) {
+        position->previous->next = position->next;
+        position->next->previous = position->previous;
+
+        return position;
+    }
+
+    ENetListIterator enet_list_move(ENetListIterator position, void *dataFirst, void *dataLast) {
+        ENetListIterator first = (ENetListIterator)dataFirst;
+        ENetListIterator last  = (ENetListIterator)dataLast;
+
+        first->previous->next = last->next;
+        last->next->previous  = first->previous;
+
+        first->previous = position->previous;
+        last->next      = position;
+
+        first->previous->next = first;
+        position->previous    = last;
+
+        return first;
+    }
+
+    size_t enet_list_size(ENetList *list) {
+        size_t size = 0;
+        ENetListIterator position;
+
+        for (position = enet_list_begin(list); position != enet_list_end(list); position = enet_list_next(position)) {
+            ++size;
+        }
+
+        return size;
+    }
+
+// =======================================================================//
+// !
+// ! Packet
+// !
+// =======================================================================//
+
+    ENetPacket *enet_packet_create(const void *data, size_t dataLength, enet_uint32 flags) {
+        ENetPacket *packet;
+
+        if (flags & ENET_PACKET_FLAG_NO_ALLOCATE) {
+            packet = (ENetPacket *)enet_malloc(sizeof(ENetPacket));
+
+            if (packet == NULL) {
+                return NULL;
+            }
+
+            packet->data = (enet_uint8 *)data;
+        } else {
+            packet = (ENetPacket *)enet_malloc(sizeof(ENetPacket) + dataLength);
+
+            if (packet == NULL) {
+                return NULL;
+            }
+
+            packet->data = (enet_uint8 *)packet + sizeof(ENetPacket);
+
+            if (data != NULL) {
+                memcpy(packet->data, data, dataLength);
+            }
+        }
+
+        packet->referenceCount = 0;
+        packet->flags        = flags;
+        packet->dataLength   = dataLength;
+        packet->freeCallback = NULL;
+        packet->userData     = NULL;
+
+        return packet;
+    }
+
+    ENetPacket *enet_packet_create_offset(const void *data, size_t dataLength, size_t dataOffset, enet_uint32 flags) {
+        ENetPacket *packet;
+
+        if (flags & ENET_PACKET_FLAG_NO_ALLOCATE) {
+            packet = (ENetPacket *)enet_malloc(sizeof(ENetPacket));
+
+            if (packet == NULL) {
+                return NULL;
+            }
+
+            packet->data = (enet_uint8 *)data;
+        } else {
+            packet = (ENetPacket *)enet_malloc(sizeof(ENetPacket) + dataLength + dataOffset);
+
+            if (packet == NULL) {
+                return NULL;
+            }
+
+            packet->data = (enet_uint8 *)packet + sizeof(ENetPacket);
+
+            if (data != NULL) {
+                memcpy(packet->data + dataOffset, data, dataLength);
+            }
+        }
+
+        packet->referenceCount = 0;
+        packet->flags        = flags;
+        packet->dataLength   = dataLength + dataOffset;
+        packet->freeCallback = NULL;
+        packet->userData     = NULL;
+
+        return packet;
+    }
+
+    void enet_packet_destroy(ENetPacket *packet) {
+        if (packet == NULL) {
+            return;
+        }
+
+        if (packet->freeCallback != NULL) {
+            (*packet->freeCallback) ((void *)packet);
+        }
+
+        enet_free(packet);
+    }
+
+    static int initializedCRC32 = 0;
+    static enet_uint32 crcTable[256];
+
+    static enet_uint32 reflect_crc(int val, int bits) {
+        int result = 0, bit;
+
+        for (bit = 0; bit < bits; bit++) {
+            if (val & 1) { result |= 1 << (bits - 1 - bit); }
+            val >>= 1;
+        }
+
+        return result;
+    }
+
+    static void initialize_crc32(void) {
+        int byte;
+
+        for (byte = 0; byte < 256; ++byte) {
+            enet_uint32 crc = reflect_crc(byte, 8) << 24;
+            int offset;
+
+            for (offset = 0; offset < 8; ++offset) {
+                if (crc & 0x80000000) {
+                    crc = (crc << 1) ^ 0x04c11db7;
+                } else {
+                    crc <<= 1;
+                }
+            }
+
+            crcTable[byte] = reflect_crc(crc, 32);
+        }
+
+        initializedCRC32 = 1;
+    }
+
+    enet_uint32 enet_crc32(const ENetBuffer *buffers, size_t bufferCount) {
+        enet_uint32 crc = 0xFFFFFFFF;
+
+        if (!initializedCRC32) { initialize_crc32(); }
+
+        while (bufferCount-- > 0) {
+            const enet_uint8 *data = (const enet_uint8 *)buffers->data;
+            const enet_uint8 *dataEnd = &data[buffers->dataLength];
+
+            while (data < dataEnd) {
+                crc = (crc >> 8) ^ crcTable[(crc & 0xFF) ^ *data++];
+            }
+
+            ++buffers;
+        }
+
+        return ENET_HOST_TO_NET_32(~crc);
+    }
+
+// =======================================================================//
+// !
+// ! Protocol
+// !
+// =======================================================================//
+
+    static size_t commandSizes[ENET_PROTOCOL_COMMAND_COUNT] = {
+        0,
+        sizeof(ENetProtocolAcknowledge),
+        sizeof(ENetProtocolConnect),
+        sizeof(ENetProtocolVerifyConnect),
+        sizeof(ENetProtocolDisconnect),
+        sizeof(ENetProtocolPing),
+        sizeof(ENetProtocolSendReliable),
+        sizeof(ENetProtocolSendUnreliable),
+        sizeof(ENetProtocolSendFragment),
+        sizeof(ENetProtocolSendUnsequenced),
+        sizeof(ENetProtocolBandwidthLimit),
+        sizeof(ENetProtocolThrottleConfigure),
+        sizeof(ENetProtocolSendFragment)
+    };
+
+    size_t enet_protocol_command_size(enet_uint8 commandNumber) {
+        return commandSizes[commandNumber & ENET_PROTOCOL_COMMAND_MASK];
+    }
+
+    static void enet_protocol_change_state(ENetHost *host, ENetPeer *peer, ENetPeerState state) {
+        if (state == ENET_PEER_STATE_CONNECTED || state == ENET_PEER_STATE_DISCONNECT_LATER) {
+            enet_peer_on_connect(peer);
+        } else {
+            enet_peer_on_disconnect(peer);
+        }
+
+        peer->state = state;
+    }
+
+    static void enet_protocol_dispatch_state(ENetHost *host, ENetPeer *peer, ENetPeerState state) {
+        enet_protocol_change_state(host, peer, state);
+
+        if (!peer->needsDispatch) {
+            enet_list_insert(enet_list_end(&host->dispatchQueue), &peer->dispatchList);
+            peer->needsDispatch = 1;
+        }
+    }
+
+    static int enet_protocol_dispatch_incoming_commands(ENetHost *host, ENetEvent *event) {
+        while (!enet_list_empty(&host->dispatchQueue)) {
+            ENetPeer *peer = (ENetPeer *)enet_list_remove(enet_list_begin(&host->dispatchQueue));
+            peer->needsDispatch = 0;
+
+            switch (peer->state) {
+                case ENET_PEER_STATE_CONNECTION_PENDING:
+                case ENET_PEER_STATE_CONNECTION_SUCCEEDED:
+                    enet_protocol_change_state(host, peer, ENET_PEER_STATE_CONNECTED);
+
+                    event->type = ENET_EVENT_TYPE_CONNECT;
+                    event->peer = peer;
+                    event->data = peer->eventData;
+
+                    return 1;
+
+                case ENET_PEER_STATE_ZOMBIE:
+                    host->recalculateBandwidthLimits = 1;
+
+                    event->type = ENET_EVENT_TYPE_DISCONNECT;
+                    event->peer = peer;
+                    event->data = peer->eventData;
+
+                    enet_peer_reset(peer);
+
+                    return 1;
+
+                case ENET_PEER_STATE_CONNECTED:
+                    if (enet_list_empty(&peer->dispatchedCommands)) {
+                        continue;
+                    }
+
+                    event->packet = enet_peer_receive(peer, &event->channelID);
+                    if (event->packet == NULL) {
+                        continue;
+                    }
+
+                    event->type = ENET_EVENT_TYPE_RECEIVE;
+                    event->peer = peer;
+
+                    if (!enet_list_empty(&peer->dispatchedCommands)) {
+                        peer->needsDispatch = 1;
+                        enet_list_insert(enet_list_end(&host->dispatchQueue), &peer->dispatchList);
+                    }
+
+                    return 1;
+
+                default:
+                    break;
+            }
+        }
+
+        return 0;
+    }
+
+    static void enet_protocol_notify_connect(ENetHost *host, ENetPeer *peer, ENetEvent *event) {
+        host->recalculateBandwidthLimits = 1;
+
+        if (event != NULL) {
+            enet_protocol_change_state(host, peer, ENET_PEER_STATE_CONNECTED);
+
+            peer->totalDataSent     = 0;
+            peer->totalDataReceived = 0;
+            peer->totalPacketsSent  = 0;
+            peer->totalPacketsLost  = 0;
+            event->type = ENET_EVENT_TYPE_CONNECT;
+            event->peer = peer;
+            event->data = peer->eventData;
+        } else {
+            enet_protocol_dispatch_state(host, peer, peer->state == ENET_PEER_STATE_CONNECTING ? ENET_PEER_STATE_CONNECTION_SUCCEEDED : ENET_PEER_STATE_CONNECTION_PENDING);
+        }
+    }
+
+    static void enet_protocol_notify_disconnect(ENetHost *host, ENetPeer *peer, ENetEvent *event) {
+        if (peer->state >= ENET_PEER_STATE_CONNECTION_PENDING) {
+            host->recalculateBandwidthLimits = 1;
+        }
+
+        if (peer->state != ENET_PEER_STATE_CONNECTING && peer->state < ENET_PEER_STATE_CONNECTION_SUCCEEDED) {
+            enet_peer_reset(peer);
+        } else if (event != NULL) {
+            event->type = ENET_EVENT_TYPE_DISCONNECT;
+            event->peer = peer;
+            event->data = 0;
+
+            enet_peer_reset(peer);
+        } else {
+            peer->eventData = 0;
+            enet_protocol_dispatch_state(host, peer, ENET_PEER_STATE_ZOMBIE);
+        }
+    }
+
+    static void enet_protocol_notify_disconnect_timeout(ENetHost * host, ENetPeer * peer, ENetEvent * event) {
+        if (peer->state >= ENET_PEER_STATE_CONNECTION_PENDING) {
+           host->recalculateBandwidthLimits = 1;
+        }
+
+        if (peer->state != ENET_PEER_STATE_CONNECTING && peer->state < ENET_PEER_STATE_CONNECTION_SUCCEEDED) {
+            enet_peer_reset (peer);
+        }
+        else if (event != NULL) {
+            event->type = ENET_EVENT_TYPE_DISCONNECT_TIMEOUT;
+            event->peer = peer;
+            event->data = 0;
+
+            enet_peer_reset(peer);
+        } else {
+            peer->eventData = 0;
+            enet_protocol_dispatch_state(host, peer, ENET_PEER_STATE_ZOMBIE);
+        }
+    }
+
+    static void enet_protocol_remove_sent_unreliable_commands(ENetPeer *peer) {
+        ENetOutgoingCommand *outgoingCommand;
+
+        while (!enet_list_empty(&peer->sentUnreliableCommands)) {
+            outgoingCommand = (ENetOutgoingCommand *)enet_list_front(&peer->sentUnreliableCommands);
+            enet_list_remove(&outgoingCommand->outgoingCommandList);
+
+            if (outgoingCommand->packet != NULL) {
+                --outgoingCommand->packet->referenceCount;
+
+                if (outgoingCommand->packet->referenceCount == 0) {
+                    outgoingCommand->packet->flags |= ENET_PACKET_FLAG_SENT;
+                    enet_packet_destroy(outgoingCommand->packet);
+                }
+            }
+
+            enet_free(outgoingCommand);
+        }
+    }
+
+    static ENetProtocolCommand enet_protocol_remove_sent_reliable_command(ENetPeer *peer, enet_uint16 reliableSequenceNumber, enet_uint8 channelID) {
+        ENetOutgoingCommand *outgoingCommand = NULL;
+        ENetListIterator currentCommand;
+        ENetProtocolCommand commandNumber;
+
+        int wasSent = 1;
+
+        for (currentCommand = enet_list_begin(&peer->sentReliableCommands);
+            currentCommand != enet_list_end(&peer->sentReliableCommands);
+            currentCommand = enet_list_next(currentCommand)
+        ) {
+            outgoingCommand = (ENetOutgoingCommand *)currentCommand;
+
+            if (outgoingCommand->reliableSequenceNumber == reliableSequenceNumber && outgoingCommand->command.header.channelID == channelID) {
+                break;
+            }
+        }
+
+        if (currentCommand == enet_list_end(&peer->sentReliableCommands)) {
+            for (currentCommand = enet_list_begin(&peer->outgoingReliableCommands);
+                currentCommand != enet_list_end(&peer->outgoingReliableCommands);
+                currentCommand = enet_list_next(currentCommand)
+            ) {
+                outgoingCommand = (ENetOutgoingCommand *)currentCommand;
+
+                if (outgoingCommand->sendAttempts < 1) {
+                    return ENET_PROTOCOL_COMMAND_NONE;
+                }
+
+                if (outgoingCommand->reliableSequenceNumber == reliableSequenceNumber && outgoingCommand->command.header.channelID == channelID) {
+                    break;
+                }
+            }
+
+            if (currentCommand == enet_list_end(&peer->outgoingReliableCommands)) {
+                return ENET_PROTOCOL_COMMAND_NONE;
+            }
+
+            wasSent = 0;
+        }
+
+        if (outgoingCommand == NULL) {
+            return ENET_PROTOCOL_COMMAND_NONE;
+        }
+
+        if (channelID < peer->channelCount) {
+            ENetChannel *channel       = &peer->channels[channelID];
+            enet_uint16 reliableWindow = reliableSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE;
+            if (channel->reliableWindows[reliableWindow] > 0) {
+                --channel->reliableWindows[reliableWindow];
+
+                if (!channel->reliableWindows[reliableWindow]) {
+                    channel->usedReliableWindows &= ~(1 << reliableWindow);
+                }
+            }
+        }
+
+        commandNumber = (ENetProtocolCommand) (outgoingCommand->command.header.command & ENET_PROTOCOL_COMMAND_MASK);
+
+        enet_list_remove(&outgoingCommand->outgoingCommandList);
+
+        if (outgoingCommand->packet != NULL) {
+            if (wasSent) {
+                peer->reliableDataInTransit -= outgoingCommand->fragmentLength;
+            }
+
+            --outgoingCommand->packet->referenceCount;
+
+            if (outgoingCommand->packet->referenceCount == 0) {
+                outgoingCommand->packet->flags |= ENET_PACKET_FLAG_SENT;
+                enet_packet_destroy(outgoingCommand->packet);
+            }
+        }
+
+        enet_free(outgoingCommand);
+
+        if (enet_list_empty(&peer->sentReliableCommands)) {
+            return commandNumber;
+        }
+
+        outgoingCommand = (ENetOutgoingCommand *)enet_list_front(&peer->sentReliableCommands);
+        peer->nextTimeout = outgoingCommand->sentTime + outgoingCommand->roundTripTimeout;
+
+        return commandNumber;
+    }
+
+    static ENetPeer * enet_protocol_handle_connect(ENetHost *host, ENetProtocolHeader *header, ENetProtocol *command) {
+        enet_uint8 incomingSessionID, outgoingSessionID;
+        enet_uint32 mtu, windowSize;
+        ENetChannel *channel;
+
+        size_t channelCount, duplicatePeers = 0;
+
+        ENetPeer *currentPeer, *peer = NULL;
+        ENetProtocol verifyCommand;
+
+        channelCount = ENET_NET_TO_HOST_32(command->connect.channelCount);
+
+        if (channelCount < ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT || channelCount > ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT) {
+            return NULL;
+        }
+
+        for (currentPeer = host->peers; currentPeer < &host->peers[host->peerCount]; ++currentPeer) {
+            if (currentPeer->state == ENET_PEER_STATE_DISCONNECTED) {
+                if (peer == NULL) {
+                    peer = currentPeer;
+                }
+            } else if (currentPeer->state != ENET_PEER_STATE_CONNECTING && in6_equal(currentPeer->address.host, host->receivedAddress.host)) {
+                if (currentPeer->address.port == host->receivedAddress.port && currentPeer->connectID == command->connect.connectID) {
+                    return NULL;
+                }
+
+                ++duplicatePeers;
+            }
+        }
+
+        if (peer == NULL || duplicatePeers >= host->duplicatePeers) {
+            return NULL;
+        }
+
+        if (channelCount > host->channelLimit) {
+            channelCount = host->channelLimit;
+        }
+
+        peer->channels = (ENetChannel *)enet_malloc(channelCount * sizeof(ENetChannel));
+
+        if (peer->channels == NULL) {
+            return NULL;
+        }
+
+        peer->channelCount               = channelCount;
+        peer->state                      = ENET_PEER_STATE_ACKNOWLEDGING_CONNECT;
+        peer->connectID                  = command->connect.connectID;
+        peer->address                    = host->receivedAddress;
+        peer->outgoingPeerID             = ENET_NET_TO_HOST_16(command->connect.outgoingPeerID);
+        peer->incomingBandwidth          = ENET_NET_TO_HOST_32(command->connect.incomingBandwidth);
+        peer->outgoingBandwidth          = ENET_NET_TO_HOST_32(command->connect.outgoingBandwidth);
+        peer->packetThrottleInterval     = ENET_NET_TO_HOST_32(command->connect.packetThrottleInterval);
+        peer->packetThrottleAcceleration = ENET_NET_TO_HOST_32(command->connect.packetThrottleAcceleration);
+        peer->packetThrottleDeceleration = ENET_NET_TO_HOST_32(command->connect.packetThrottleDeceleration);
+        peer->eventData                  = ENET_NET_TO_HOST_32(command->connect.data);
+
+        incomingSessionID = command->connect.incomingSessionID == 0xFF ? peer->outgoingSessionID : command->connect.incomingSessionID;
+        incomingSessionID = (incomingSessionID + 1) & (ENET_PROTOCOL_HEADER_SESSION_MASK >> ENET_PROTOCOL_HEADER_SESSION_SHIFT);
+
+        if (incomingSessionID == peer->outgoingSessionID) {
+            incomingSessionID = (incomingSessionID + 1)
+              & (ENET_PROTOCOL_HEADER_SESSION_MASK >> ENET_PROTOCOL_HEADER_SESSION_SHIFT);
+        }
+
+        peer->outgoingSessionID = incomingSessionID;
+
+        outgoingSessionID = command->connect.outgoingSessionID == 0xFF ? peer->incomingSessionID : command->connect.outgoingSessionID;
+        outgoingSessionID = (outgoingSessionID + 1) & (ENET_PROTOCOL_HEADER_SESSION_MASK >> ENET_PROTOCOL_HEADER_SESSION_SHIFT);
+
+        if (outgoingSessionID == peer->incomingSessionID) {
+            outgoingSessionID = (outgoingSessionID + 1)
+              & (ENET_PROTOCOL_HEADER_SESSION_MASK >> ENET_PROTOCOL_HEADER_SESSION_SHIFT);
+        }
+
+        peer->incomingSessionID = outgoingSessionID;
+
+        for (channel = peer->channels; channel < &peer->channels[channelCount]; ++channel) {
+            channel->outgoingReliableSequenceNumber   = 0;
+            channel->outgoingUnreliableSequenceNumber = 0;
+            channel->incomingReliableSequenceNumber   = 0;
+            channel->incomingUnreliableSequenceNumber = 0;
+
+            enet_list_clear(&channel->incomingReliableCommands);
+            enet_list_clear(&channel->incomingUnreliableCommands);
+
+            channel->usedReliableWindows = 0;
+            memset(channel->reliableWindows, 0, sizeof(channel->reliableWindows));
+        }
+
+        mtu = ENET_NET_TO_HOST_32(command->connect.mtu);
+
+        if (mtu < ENET_PROTOCOL_MINIMUM_MTU) {
+            mtu = ENET_PROTOCOL_MINIMUM_MTU;
+        } else if (mtu > ENET_PROTOCOL_MAXIMUM_MTU) {
+            mtu = ENET_PROTOCOL_MAXIMUM_MTU;
+        }
+
+        peer->mtu = mtu;
+
+        if (host->outgoingBandwidth == 0 && peer->incomingBandwidth == 0) {
+            peer->windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
+        } else if (host->outgoingBandwidth == 0 || peer->incomingBandwidth == 0) {
+            peer->windowSize = (ENET_MAX(host->outgoingBandwidth, peer->incomingBandwidth) / ENET_PEER_WINDOW_SIZE_SCALE) * ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
+        } else {
+            peer->windowSize = (ENET_MIN(host->outgoingBandwidth, peer->incomingBandwidth) / ENET_PEER_WINDOW_SIZE_SCALE) * ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
+        }
+
+        if (peer->windowSize < ENET_PROTOCOL_MINIMUM_WINDOW_SIZE) {
+            peer->windowSize = ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
+        } else if (peer->windowSize > ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE) {
+            peer->windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
+        }
+
+        if (host->incomingBandwidth == 0) {
+            windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
+        } else {
+            windowSize = (host->incomingBandwidth / ENET_PEER_WINDOW_SIZE_SCALE) * ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
+        }
+
+        if (windowSize > ENET_NET_TO_HOST_32(command->connect.windowSize)) {
+            windowSize = ENET_NET_TO_HOST_32(command->connect.windowSize);
+        }
+
+        if (windowSize < ENET_PROTOCOL_MINIMUM_WINDOW_SIZE) {
+            windowSize = ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
+        } else if (windowSize > ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE) {
+            windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
+        }
+
+        verifyCommand.header.command                            = ENET_PROTOCOL_COMMAND_VERIFY_CONNECT | ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE;
+        verifyCommand.header.channelID                          = 0xFF;
+        verifyCommand.verifyConnect.outgoingPeerID              = ENET_HOST_TO_NET_16(peer->incomingPeerID);
+        verifyCommand.verifyConnect.incomingSessionID           = incomingSessionID;
+        verifyCommand.verifyConnect.outgoingSessionID           = outgoingSessionID;
+        verifyCommand.verifyConnect.mtu                         = ENET_HOST_TO_NET_32(peer->mtu);
+        verifyCommand.verifyConnect.windowSize                  = ENET_HOST_TO_NET_32(windowSize);
+        verifyCommand.verifyConnect.channelCount                = ENET_HOST_TO_NET_32(channelCount);
+        verifyCommand.verifyConnect.incomingBandwidth           = ENET_HOST_TO_NET_32(host->incomingBandwidth);
+        verifyCommand.verifyConnect.outgoingBandwidth           = ENET_HOST_TO_NET_32(host->outgoingBandwidth);
+        verifyCommand.verifyConnect.packetThrottleInterval      = ENET_HOST_TO_NET_32(peer->packetThrottleInterval);
+        verifyCommand.verifyConnect.packetThrottleAcceleration  = ENET_HOST_TO_NET_32(peer->packetThrottleAcceleration);
+        verifyCommand.verifyConnect.packetThrottleDeceleration  = ENET_HOST_TO_NET_32(peer->packetThrottleDeceleration);
+        verifyCommand.verifyConnect.connectID                   = peer->connectID;
+
+        enet_peer_queue_outgoing_command(peer, &verifyCommand, NULL, 0, 0);
+
+        return peer;
+    }
+
+    static int enet_protocol_handle_send_reliable(ENetHost *host, ENetPeer *peer, const ENetProtocol *command, enet_uint8 **currentData) {
+        size_t dataLength;
+
+        if (command->header.channelID >= peer->channelCount || (peer->state != ENET_PEER_STATE_CONNECTED && peer->state != ENET_PEER_STATE_DISCONNECT_LATER)) {
+            return -1;
+        }
+
+        dataLength    = ENET_NET_TO_HOST_16(command->sendReliable.dataLength);
+        *currentData += dataLength;
+
+        if (dataLength > host->maximumPacketSize || *currentData < host->receivedData || *currentData > &host->receivedData[host->receivedDataLength]) {
+            return -1;
+        }
+
+        if (enet_peer_queue_incoming_command(peer, command, (const enet_uint8 *)command + sizeof(ENetProtocolSendReliable), dataLength, ENET_PACKET_FLAG_RELIABLE, 0) == NULL) {
+            return -1;
+        }
+
+        return 0;
+    }
+
+    static int enet_protocol_handle_send_unsequenced(ENetHost *host, ENetPeer *peer, const ENetProtocol *command, enet_uint8 **currentData) {
+        enet_uint32 unsequencedGroup, index;
+
+        size_t dataLength;
+
+        if (command->header.channelID >= peer->channelCount || (peer->state != ENET_PEER_STATE_CONNECTED && peer->state != ENET_PEER_STATE_DISCONNECT_LATER)) {
+            return -1;
+        }
+
+        dataLength    = ENET_NET_TO_HOST_16(command->sendUnsequenced.dataLength);
+        *currentData += dataLength;
+
+        if (dataLength > host->maximumPacketSize || *currentData < host->receivedData || *currentData > &host->receivedData[host->receivedDataLength]) {
+            return -1;
+        }
+
+        unsequencedGroup = ENET_NET_TO_HOST_16(command->sendUnsequenced.unsequencedGroup);
+        index = unsequencedGroup % ENET_PEER_UNSEQUENCED_WINDOW_SIZE;
+
+        if (unsequencedGroup < peer->incomingUnsequencedGroup) {
+            unsequencedGroup += 0x10000;
+        }
+
+        if (unsequencedGroup >= (enet_uint32) peer->incomingUnsequencedGroup + ENET_PEER_FREE_UNSEQUENCED_WINDOWS * ENET_PEER_UNSEQUENCED_WINDOW_SIZE) {
+            return 0;
+        }
+
+        unsequencedGroup &= 0xFFFF;
+
+        if (unsequencedGroup - index != peer->incomingUnsequencedGroup) {
+            peer->incomingUnsequencedGroup = unsequencedGroup - index;
+            memset(peer->unsequencedWindow, 0, sizeof(peer->unsequencedWindow));
+        } else if (peer->unsequencedWindow[index / 32] & (1 << (index % 32))) {
+            return 0;
+        }
+
+        if (enet_peer_queue_incoming_command(peer, command, (const enet_uint8 *)command + sizeof(ENetProtocolSendUnsequenced), dataLength, ENET_PACKET_FLAG_UNSEQUENCED,0) == NULL) {
+            return -1;
+        }
+
+        peer->unsequencedWindow[index / 32] |= 1 << (index % 32);
+
+        return 0;
+    }
+
+    static int enet_protocol_handle_send_unreliable(ENetHost *host, ENetPeer *peer, const ENetProtocol *command, enet_uint8 **currentData) {
+        size_t dataLength;
+
+        if (command->header.channelID >= peer->channelCount || (peer->state != ENET_PEER_STATE_CONNECTED && peer->state != ENET_PEER_STATE_DISCONNECT_LATER)) {
+            return -1;
+        }
+
+        dataLength    = ENET_NET_TO_HOST_16(command->sendUnreliable.dataLength);
+        *currentData += dataLength;
+
+        if (dataLength > host->maximumPacketSize || *currentData < host->receivedData || *currentData > &host->receivedData[host->receivedDataLength]) {
+            return -1;
+        }
+
+        if (enet_peer_queue_incoming_command(peer, command, (const enet_uint8 *)command + sizeof(ENetProtocolSendUnreliable), dataLength, 0, 0) == NULL) {
+            return -1;
+        }
+
+        return 0;
+    }
+
+    static int enet_protocol_handle_send_fragment(ENetHost *host, ENetPeer *peer, const ENetProtocol *command, enet_uint8 **currentData) {
+        enet_uint32 fragmentNumber, fragmentCount, fragmentOffset, fragmentLength, startSequenceNumber, totalLength;
+        ENetChannel *channel;
+        enet_uint16 startWindow, currentWindow;
+        ENetListIterator currentCommand;
+        ENetIncomingCommand *startCommand = NULL;
+
+        if (command->header.channelID >= peer->channelCount || (peer->state != ENET_PEER_STATE_CONNECTED && peer->state != ENET_PEER_STATE_DISCONNECT_LATER)) {
+            return -1;
+        }
+
+        fragmentLength = ENET_NET_TO_HOST_16(command->sendFragment.dataLength);
+        *currentData  += fragmentLength;
+
+        if (fragmentLength > host->maximumPacketSize || *currentData < host->receivedData || *currentData > &host->receivedData[host->receivedDataLength]) {
+            return -1;
+        }
+
+        channel = &peer->channels[command->header.channelID];
+        startSequenceNumber = ENET_NET_TO_HOST_16(command->sendFragment.startSequenceNumber);
+        startWindow         = startSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE;
+        currentWindow       = channel->incomingReliableSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE;
+
+        if (startSequenceNumber < channel->incomingReliableSequenceNumber) {
+            startWindow += ENET_PEER_RELIABLE_WINDOWS;
+        }
+
+        if (startWindow < currentWindow || startWindow >= currentWindow + ENET_PEER_FREE_RELIABLE_WINDOWS - 1) {
+            return 0;
+        }
+
+        fragmentNumber = ENET_NET_TO_HOST_32(command->sendFragment.fragmentNumber);
+        fragmentCount  = ENET_NET_TO_HOST_32(command->sendFragment.fragmentCount);
+        fragmentOffset = ENET_NET_TO_HOST_32(command->sendFragment.fragmentOffset);
+        totalLength    = ENET_NET_TO_HOST_32(command->sendFragment.totalLength);
+
+        if (fragmentCount > ENET_PROTOCOL_MAXIMUM_FRAGMENT_COUNT ||
+            fragmentNumber >= fragmentCount ||
+            totalLength > host->maximumPacketSize ||
+            fragmentOffset >= totalLength ||
+            fragmentLength > totalLength - fragmentOffset
+        ) {
+            return -1;
+        }
+
+        for (currentCommand = enet_list_previous(enet_list_end(&channel->incomingReliableCommands));
+            currentCommand != enet_list_end(&channel->incomingReliableCommands);
+            currentCommand = enet_list_previous(currentCommand)
+        ) {
+            ENetIncomingCommand *incomingCommand = (ENetIncomingCommand *)currentCommand;
+
+            if (startSequenceNumber >= channel->incomingReliableSequenceNumber) {
+                if (incomingCommand->reliableSequenceNumber < channel->incomingReliableSequenceNumber) {
+                    continue;
+                }
+            } else if (incomingCommand->reliableSequenceNumber >= channel->incomingReliableSequenceNumber) {
+                break;
+            }
+
+            if (incomingCommand->reliableSequenceNumber <= startSequenceNumber) {
+                if (incomingCommand->reliableSequenceNumber < startSequenceNumber) {
+                    break;
+                }
+
+                if ((incomingCommand->command.header.command & ENET_PROTOCOL_COMMAND_MASK) !=
+                    ENET_PROTOCOL_COMMAND_SEND_FRAGMENT ||
+                    totalLength != incomingCommand->packet->dataLength ||
+                    fragmentCount != incomingCommand->fragmentCount
+                ) {
+                    return -1;
+                }
+
+                startCommand = incomingCommand;
+
+                break;
+            }
+        }
+
+        if (startCommand == NULL) {
+            ENetProtocol hostCommand = *command;
+            hostCommand.header.reliableSequenceNumber = startSequenceNumber;
+            startCommand = enet_peer_queue_incoming_command(peer, &hostCommand, NULL, totalLength, ENET_PACKET_FLAG_RELIABLE, fragmentCount);
+
+            if (startCommand == NULL) {
+                return -1;
+            }
+        }
+
+        if ((startCommand->fragments[fragmentNumber / 32] & (1 << (fragmentNumber % 32))) == 0) {
+            --startCommand->fragmentsRemaining;
+            startCommand->fragments[fragmentNumber / 32] |= (1 << (fragmentNumber % 32));
+
+            if (fragmentOffset + fragmentLength > startCommand->packet->dataLength) {
+                fragmentLength = startCommand->packet->dataLength - fragmentOffset;
+            }
+
+            memcpy(startCommand->packet->data + fragmentOffset, (enet_uint8 *)command + sizeof(ENetProtocolSendFragment), fragmentLength);
+
+            if (startCommand->fragmentsRemaining <= 0) {
+                enet_peer_dispatch_incoming_reliable_commands(peer, channel);
+            }
+        }
+
+        return 0;
+    }
+
+    static int enet_protocol_handle_send_unreliable_fragment(ENetHost *host, ENetPeer *peer, const ENetProtocol *command, enet_uint8 **currentData) {
+        enet_uint32 fragmentNumber, fragmentCount, fragmentOffset, fragmentLength, reliableSequenceNumber, startSequenceNumber, totalLength;
+        enet_uint16 reliableWindow, currentWindow;
+        ENetChannel *channel;
+        ENetListIterator currentCommand;
+        ENetIncomingCommand *startCommand = NULL;
+
+        if (command->header.channelID >= peer->channelCount || (peer->state != ENET_PEER_STATE_CONNECTED && peer->state != ENET_PEER_STATE_DISCONNECT_LATER)) {
+            return -1;
+        }
+
+        fragmentLength = ENET_NET_TO_HOST_16(command->sendFragment.dataLength);
+        *currentData  += fragmentLength;
+
+        if (fragmentLength > host->maximumPacketSize || *currentData < host->receivedData || *currentData > &host->receivedData[host->receivedDataLength]) {
+            return -1;
+        }
+
+        channel = &peer->channels[command->header.channelID];
+        reliableSequenceNumber = command->header.reliableSequenceNumber;
+        startSequenceNumber    = ENET_NET_TO_HOST_16(command->sendFragment.startSequenceNumber);
+
+        reliableWindow = reliableSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE;
+        currentWindow  = channel->incomingReliableSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE;
+
+        if (reliableSequenceNumber < channel->incomingReliableSequenceNumber) {
+            reliableWindow += ENET_PEER_RELIABLE_WINDOWS;
+        }
+
+        if (reliableWindow < currentWindow || reliableWindow >= currentWindow + ENET_PEER_FREE_RELIABLE_WINDOWS - 1) {
+            return 0;
+        }
+
+        if (reliableSequenceNumber == channel->incomingReliableSequenceNumber && startSequenceNumber <= channel->incomingUnreliableSequenceNumber) {
+            return 0;
+        }
+
+        fragmentNumber = ENET_NET_TO_HOST_32(command->sendFragment.fragmentNumber);
+        fragmentCount  = ENET_NET_TO_HOST_32(command->sendFragment.fragmentCount);
+        fragmentOffset = ENET_NET_TO_HOST_32(command->sendFragment.fragmentOffset);
+        totalLength    = ENET_NET_TO_HOST_32(command->sendFragment.totalLength);
+
+        if (fragmentCount > ENET_PROTOCOL_MAXIMUM_FRAGMENT_COUNT ||
+            fragmentNumber >= fragmentCount ||
+            totalLength > host->maximumPacketSize ||
+            fragmentOffset >= totalLength ||
+            fragmentLength > totalLength - fragmentOffset
+        ) {
+            return -1;
+        }
+
+        for (currentCommand = enet_list_previous(enet_list_end(&channel->incomingUnreliableCommands));
+            currentCommand != enet_list_end(&channel->incomingUnreliableCommands);
+            currentCommand = enet_list_previous(currentCommand)
+        ) {
+            ENetIncomingCommand *incomingCommand = (ENetIncomingCommand *)currentCommand;
+
+            if (reliableSequenceNumber >= channel->incomingReliableSequenceNumber) {
+                if (incomingCommand->reliableSequenceNumber < channel->incomingReliableSequenceNumber) {
+                    continue;
+                }
+            } else if (incomingCommand->reliableSequenceNumber >= channel->incomingReliableSequenceNumber) {
+                break;
+            }
+
+            if (incomingCommand->reliableSequenceNumber < reliableSequenceNumber) {
+                break;
+            }
+
+            if (incomingCommand->reliableSequenceNumber > reliableSequenceNumber) {
+                continue;
+            }
+
+            if (incomingCommand->unreliableSequenceNumber <= startSequenceNumber) {
+                if (incomingCommand->unreliableSequenceNumber < startSequenceNumber) {
+                    break;
+                }
+
+                if ((incomingCommand->command.header.command & ENET_PROTOCOL_COMMAND_MASK) !=
+                    ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE_FRAGMENT ||
+                    totalLength != incomingCommand->packet->dataLength ||
+                    fragmentCount != incomingCommand->fragmentCount
+                ) {
+                    return -1;
+                }
+
+                startCommand = incomingCommand;
+
+                break;
+            }
+        }
+
+        if (startCommand == NULL) {
+            startCommand = enet_peer_queue_incoming_command(peer, command, NULL, totalLength,
+                ENET_PACKET_FLAG_UNRELIABLE_FRAGMENT, fragmentCount);
+            if (startCommand == NULL) {
+                return -1;
+            }
+        }
+
+        if ((startCommand->fragments[fragmentNumber / 32] & (1 << (fragmentNumber % 32))) == 0) {
+            --startCommand->fragmentsRemaining;
+            startCommand->fragments[fragmentNumber / 32] |= (1 << (fragmentNumber % 32));
+
+            if (fragmentOffset + fragmentLength > startCommand->packet->dataLength) {
+                fragmentLength = startCommand->packet->dataLength - fragmentOffset;
+            }
+
+            memcpy(startCommand->packet->data + fragmentOffset, (enet_uint8 *)command + sizeof(ENetProtocolSendFragment), fragmentLength);
+
+            if (startCommand->fragmentsRemaining <= 0) {
+                enet_peer_dispatch_incoming_unreliable_commands(peer, channel);
+            }
+        }
+
+        return 0;
+    }
+
+    static int enet_protocol_handle_ping(ENetHost *host, ENetPeer *peer, const ENetProtocol *command) {
+        if (peer->state != ENET_PEER_STATE_CONNECTED && peer->state != ENET_PEER_STATE_DISCONNECT_LATER) {
+            return -1;
+        }
+
+        return 0;
+    }
+
+    static int enet_protocol_handle_bandwidth_limit(ENetHost *host, ENetPeer *peer, const ENetProtocol *command) {
+        if (peer->state != ENET_PEER_STATE_CONNECTED && peer->state != ENET_PEER_STATE_DISCONNECT_LATER) {
+            return -1;
+        }
+
+        if (peer->incomingBandwidth != 0) {
+            --host->bandwidthLimitedPeers;
+        }
+
+        peer->incomingBandwidth = ENET_NET_TO_HOST_32(command->bandwidthLimit.incomingBandwidth);
+        peer->outgoingBandwidth = ENET_NET_TO_HOST_32(command->bandwidthLimit.outgoingBandwidth);
+
+        if (peer->incomingBandwidth != 0) {
+            ++host->bandwidthLimitedPeers;
+        }
+
+        if (peer->incomingBandwidth == 0 && host->outgoingBandwidth == 0) {
+            peer->windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
+        } else if (peer->incomingBandwidth == 0 || host->outgoingBandwidth == 0) {
+            peer->windowSize = (ENET_MAX(peer->incomingBandwidth, host->outgoingBandwidth)
+              / ENET_PEER_WINDOW_SIZE_SCALE) * ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
+        } else {
+            peer->windowSize = (ENET_MIN(peer->incomingBandwidth, host->outgoingBandwidth)
+              / ENET_PEER_WINDOW_SIZE_SCALE) * ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
+        }
+
+        if (peer->windowSize < ENET_PROTOCOL_MINIMUM_WINDOW_SIZE) {
+            peer->windowSize = ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
+        } else if (peer->windowSize > ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE) {
+            peer->windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
+        }
+
+        return 0;
+    }
+
+    static int enet_protocol_handle_throttle_configure(ENetHost *host, ENetPeer *peer, const ENetProtocol *command) {
+        if (peer->state != ENET_PEER_STATE_CONNECTED && peer->state != ENET_PEER_STATE_DISCONNECT_LATER) {
+            return -1;
+        }
+
+        peer->packetThrottleInterval     = ENET_NET_TO_HOST_32(command->throttleConfigure.packetThrottleInterval);
+        peer->packetThrottleAcceleration = ENET_NET_TO_HOST_32(command->throttleConfigure.packetThrottleAcceleration);
+        peer->packetThrottleDeceleration = ENET_NET_TO_HOST_32(command->throttleConfigure.packetThrottleDeceleration);
+
+        return 0;
+    }
+
+    static int enet_protocol_handle_disconnect(ENetHost *host, ENetPeer *peer, const ENetProtocol *command) {
+        if (peer->state == ENET_PEER_STATE_DISCONNECTED || peer->state == ENET_PEER_STATE_ZOMBIE ||
+            peer->state == ENET_PEER_STATE_ACKNOWLEDGING_DISCONNECT
+        ) {
+            return 0;
+        }
+
+        enet_peer_reset_queues(peer);
+
+        if (peer->state == ENET_PEER_STATE_CONNECTION_SUCCEEDED || peer->state == ENET_PEER_STATE_DISCONNECTING || peer->state == ENET_PEER_STATE_CONNECTING) {
+            enet_protocol_dispatch_state(host, peer, ENET_PEER_STATE_ZOMBIE);
+        } else if (peer->state != ENET_PEER_STATE_CONNECTED && peer->state != ENET_PEER_STATE_DISCONNECT_LATER) {
+            if (peer->state == ENET_PEER_STATE_CONNECTION_PENDING) { host->recalculateBandwidthLimits = 1; }
+            enet_peer_reset(peer);
+        } else if (command->header.command & ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE) {
+            enet_protocol_change_state(host, peer, ENET_PEER_STATE_ACKNOWLEDGING_DISCONNECT);
+        } else {
+            enet_protocol_dispatch_state(host, peer, ENET_PEER_STATE_ZOMBIE);
+        }
+
+        if (peer->state != ENET_PEER_STATE_DISCONNECTED) {
+            peer->eventData = ENET_NET_TO_HOST_32(command->disconnect.data);
+        }
+
+        return 0;
+    }
+
+    static int enet_protocol_handle_acknowledge(ENetHost *host, ENetEvent *event, ENetPeer *peer, const ENetProtocol *command) {
+        enet_uint32 roundTripTime, receivedSentTime, receivedReliableSequenceNumber;
+        ENetProtocolCommand commandNumber;
+
+        if (peer->state == ENET_PEER_STATE_DISCONNECTED || peer->state == ENET_PEER_STATE_ZOMBIE) {
+            return 0;
+        }
+
+        receivedSentTime  = ENET_NET_TO_HOST_16(command->acknowledge.receivedSentTime);
+        receivedSentTime |= host->serviceTime & 0xFFFF0000;
+
+        if ((receivedSentTime & 0x8000) > (host->serviceTime & 0x8000)) {
+            receivedSentTime -= 0x10000;
+        }
+
+        if (ENET_TIME_LESS(host->serviceTime, receivedSentTime)) {
+            return 0;
+        }
+
+        peer->lastReceiveTime = host->serviceTime;
+        peer->earliestTimeout = 0;
+        roundTripTime = ENET_TIME_DIFFERENCE(host->serviceTime, receivedSentTime);
+
+        enet_peer_throttle(peer, roundTripTime);
+        peer->roundTripTimeVariance -= peer->roundTripTimeVariance / 4;
+
+        if (roundTripTime >= peer->roundTripTime) {
+            peer->roundTripTime         += (roundTripTime - peer->roundTripTime) / 8;
+            peer->roundTripTimeVariance += (roundTripTime - peer->roundTripTime) / 4;
+        } else {
+            peer->roundTripTime         -= (peer->roundTripTime - roundTripTime) / 8;
+            peer->roundTripTimeVariance += (peer->roundTripTime - roundTripTime) / 4;
+        }
+
+        if (peer->roundTripTime < peer->lowestRoundTripTime) {
+            peer->lowestRoundTripTime = peer->roundTripTime;
+        }
+
+        if (peer->roundTripTimeVariance > peer->highestRoundTripTimeVariance) {
+            peer->highestRoundTripTimeVariance = peer->roundTripTimeVariance;
+        }
+
+        if (peer->packetThrottleEpoch == 0 ||
+            ENET_TIME_DIFFERENCE(host->serviceTime, peer->packetThrottleEpoch) >= peer->packetThrottleInterval
+        ) {
+            peer->lastRoundTripTime            = peer->lowestRoundTripTime;
+            peer->lastRoundTripTimeVariance    = peer->highestRoundTripTimeVariance;
+            peer->lowestRoundTripTime          = peer->roundTripTime;
+            peer->highestRoundTripTimeVariance = peer->roundTripTimeVariance;
+            peer->packetThrottleEpoch          = host->serviceTime;
+        }
+
+        receivedReliableSequenceNumber = ENET_NET_TO_HOST_16(command->acknowledge.receivedReliableSequenceNumber);
+        commandNumber = enet_protocol_remove_sent_reliable_command(peer, receivedReliableSequenceNumber, command->header.channelID);
+
+        switch (peer->state) {
+            case ENET_PEER_STATE_ACKNOWLEDGING_CONNECT:
+                if (commandNumber != ENET_PROTOCOL_COMMAND_VERIFY_CONNECT) {
+                    return -1;
+                }
+
+                enet_protocol_notify_connect(host, peer, event);
+                break;
+
+            case ENET_PEER_STATE_DISCONNECTING:
+                if (commandNumber != ENET_PROTOCOL_COMMAND_DISCONNECT) {
+                    return -1;
+                }
+
+                enet_protocol_notify_disconnect(host, peer, event);
+                break;
+
+            case ENET_PEER_STATE_DISCONNECT_LATER:
+                if (enet_list_empty(&peer->outgoingReliableCommands) &&
+                  enet_list_empty(&peer->outgoingUnreliableCommands) &&
+                  enet_list_empty(&peer->sentReliableCommands))
+                {
+                    enet_peer_disconnect(peer, peer->eventData);
+                }
+                break;
+
+            default:
+                break;
+        }
+
+        return 0;
+    }
+
+    static int enet_protocol_handle_verify_connect(ENetHost *host, ENetEvent *event, ENetPeer *peer, const ENetProtocol *command) {
+        enet_uint32 mtu, windowSize;
+        size_t channelCount;
+
+        if (peer->state != ENET_PEER_STATE_CONNECTING) {
+            return 0;
+        }
+
+        channelCount = ENET_NET_TO_HOST_32(command->verifyConnect.channelCount);
+
+        if (channelCount < ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT || channelCount > ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT ||
+            ENET_NET_TO_HOST_32(command->verifyConnect.packetThrottleInterval) != peer->packetThrottleInterval ||
+            ENET_NET_TO_HOST_32(command->verifyConnect.packetThrottleAcceleration) != peer->packetThrottleAcceleration ||
+            ENET_NET_TO_HOST_32(command->verifyConnect.packetThrottleDeceleration) != peer->packetThrottleDeceleration ||
+            command->verifyConnect.connectID != peer->connectID
+        ) {
+            peer->eventData = 0;
+
+            enet_protocol_dispatch_state(host, peer, ENET_PEER_STATE_ZOMBIE);
+
+            return -1;
+        }
+
+        enet_protocol_remove_sent_reliable_command(peer, 1, 0xFF);
+
+        if (channelCount < peer->channelCount) {
+            peer->channelCount = channelCount;
+        }
+
+        peer->outgoingPeerID    = ENET_NET_TO_HOST_16(command->verifyConnect.outgoingPeerID);
+        peer->incomingSessionID = command->verifyConnect.incomingSessionID;
+        peer->outgoingSessionID = command->verifyConnect.outgoingSessionID;
+
+        mtu = ENET_NET_TO_HOST_32(command->verifyConnect.mtu);
+
+        if (mtu < ENET_PROTOCOL_MINIMUM_MTU) {
+            mtu = ENET_PROTOCOL_MINIMUM_MTU;
+        } else if (mtu > ENET_PROTOCOL_MAXIMUM_MTU) {
+            mtu = ENET_PROTOCOL_MAXIMUM_MTU;
+        }
+
+        if (mtu < peer->mtu) {
+            peer->mtu = mtu;
+        }
+
+        windowSize = ENET_NET_TO_HOST_32(command->verifyConnect.windowSize);
+
+        if (windowSize < ENET_PROTOCOL_MINIMUM_WINDOW_SIZE) {
+            windowSize = ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
+        }
+
+        if (windowSize > ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE) {
+            windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
+        }
+
+        if (windowSize < peer->windowSize) {
+            peer->windowSize = windowSize;
+        }
+
+        peer->incomingBandwidth = ENET_NET_TO_HOST_32(command->verifyConnect.incomingBandwidth);
+        peer->outgoingBandwidth = ENET_NET_TO_HOST_32(command->verifyConnect.outgoingBandwidth);
+
+        enet_protocol_notify_connect(host, peer, event);
+
+        return 0;
+    }
+
+    static int enet_protocol_handle_incoming_commands(ENetHost *host, ENetEvent *event) {
+        ENetProtocolHeader *header;
+        ENetProtocol *command;
+        ENetPeer *peer;
+        enet_uint8 *currentData;
+        size_t headerSize;
+        enet_uint16 peerID, flags;
+        enet_uint8 sessionID;
+
+        if (host->receivedDataLength < (size_t) &((ENetProtocolHeader *)0)->sentTime) {
+            return 0;
+        }
+
+        header = (ENetProtocolHeader *)host->receivedData;
+
+        peerID    = ENET_NET_TO_HOST_16(header->peerID);
+        sessionID = (peerID & ENET_PROTOCOL_HEADER_SESSION_MASK) >> ENET_PROTOCOL_HEADER_SESSION_SHIFT;
+        flags     = peerID & ENET_PROTOCOL_HEADER_FLAG_MASK;
+        peerID   &= ~(ENET_PROTOCOL_HEADER_FLAG_MASK | ENET_PROTOCOL_HEADER_SESSION_MASK);
+
+        headerSize = (flags & ENET_PROTOCOL_HEADER_FLAG_SENT_TIME ? sizeof(ENetProtocolHeader) : (size_t) &((ENetProtocolHeader *)0)->sentTime);
+
+        if (host->checksum != NULL) {
+            headerSize += sizeof(enet_uint32);
+        }
+
+        if (peerID == ENET_PROTOCOL_MAXIMUM_PEER_ID) {
+            peer = NULL;
+        } else if (peerID >= host->peerCount) {
+            return 0;
+        } else {
+            peer = &host->peers[peerID];
+
+            if (peer->state == ENET_PEER_STATE_DISCONNECTED ||
+                peer->state == ENET_PEER_STATE_ZOMBIE ||
+                ((!in6_equal(host->receivedAddress.host , peer->address.host) ||
+                host->receivedAddress.port != peer->address.port) &&
+                1 /* No broadcast in IPv6 - !in6_equal(peer->address.host , ENET_HOST_BROADCAST) */) ||
+                (peer->outgoingPeerID < ENET_PROTOCOL_MAXIMUM_PEER_ID &&
+                sessionID != peer->incomingSessionID)
+            ) {
+                return 0;
+            }
+        }
+
+        if (host->checksum != NULL) {
+            enet_uint32 *checksum = (enet_uint32 *)&host->receivedData[headerSize - sizeof(enet_uint32)];
+            enet_uint32 desiredChecksum = *checksum;
+            ENetBuffer buffer;
+
+            *checksum = peer != NULL ? peer->connectID : 0;
+
+            buffer.data       = host->receivedData;
+            buffer.dataLength = host->receivedDataLength;
+
+            if (host->checksum(&buffer, 1) != desiredChecksum) {
+                return 0;
+            }
+        }
+
+        if (peer != NULL) {
+            peer->address.host       = host->receivedAddress.host;
+            peer->address.port       = host->receivedAddress.port;
+            peer->incomingDataTotal += host->receivedDataLength;
+            peer->totalDataReceived += host->receivedDataLength;
+        }
+
+        currentData = host->receivedData + headerSize;
+
+        while (currentData < &host->receivedData[host->receivedDataLength]) {
+            enet_uint8 commandNumber;
+            size_t commandSize;
+
+            command = (ENetProtocol *)currentData;
+
+            if (currentData + sizeof(ENetProtocolCommandHeader) > &host->receivedData[host->receivedDataLength]) {
+                break;
+            }
+
+            commandNumber = command->header.command & ENET_PROTOCOL_COMMAND_MASK;
+
+            if (commandNumber >= ENET_PROTOCOL_COMMAND_COUNT) {
+                break;
+            }
+
+            commandSize = commandSizes[commandNumber];
+
+            if (commandSize == 0 || currentData + commandSize > &host->receivedData[host->receivedDataLength]) {
+                break;
+            }
+
+            currentData += commandSize;
+
+            if (peer == NULL && (commandNumber != ENET_PROTOCOL_COMMAND_CONNECT || currentData < &host->receivedData[host->receivedDataLength])) {
+                break;
+            }
+
+            command->header.reliableSequenceNumber = ENET_NET_TO_HOST_16(command->header.reliableSequenceNumber);
+
+            switch (commandNumber) {
+                case ENET_PROTOCOL_COMMAND_ACKNOWLEDGE:
+                    if (enet_protocol_handle_acknowledge(host, event, peer, command)) {
+                        goto commandError;
+                    }
+                    break;
+
+                case ENET_PROTOCOL_COMMAND_CONNECT:
+                    if (peer != NULL) {
+                        goto commandError;
+                    }
+                    peer = enet_protocol_handle_connect(host, header, command);
+                    if (peer == NULL) {
+                        goto commandError;
+                    }
+                    break;
+
+                case ENET_PROTOCOL_COMMAND_VERIFY_CONNECT:
+                    if (enet_protocol_handle_verify_connect(host, event, peer, command)) {
+                        goto commandError;
+                    }
+                    break;
+
+                case ENET_PROTOCOL_COMMAND_DISCONNECT:
+                    if (enet_protocol_handle_disconnect(host, peer, command)) {
+                        goto commandError;
+                    }
+                    break;
+
+                case ENET_PROTOCOL_COMMAND_PING:
+                    if (enet_protocol_handle_ping(host, peer, command)) {
+                        goto commandError;
+                    }
+                    break;
+
+                case ENET_PROTOCOL_COMMAND_SEND_RELIABLE:
+                    if (enet_protocol_handle_send_reliable(host, peer, command, &currentData)) {
+                        goto commandError;
+                    }
+                    break;
+
+                case ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE:
+                    if (enet_protocol_handle_send_unreliable(host, peer, command, &currentData)) {
+                        goto commandError;
+                    }
+                    break;
+
+                case ENET_PROTOCOL_COMMAND_SEND_UNSEQUENCED:
+                    if (enet_protocol_handle_send_unsequenced(host, peer, command, &currentData)) {
+                        goto commandError;
+                    }
+                    break;
+
+                case ENET_PROTOCOL_COMMAND_SEND_FRAGMENT:
+                    if (enet_protocol_handle_send_fragment(host, peer, command, &currentData)) {
+                        goto commandError;
+                    }
+                    break;
+
+                case ENET_PROTOCOL_COMMAND_BANDWIDTH_LIMIT:
+                    if (enet_protocol_handle_bandwidth_limit(host, peer, command)) {
+                        goto commandError;
+                    }
+                    break;
+
+                case ENET_PROTOCOL_COMMAND_THROTTLE_CONFIGURE:
+                    if (enet_protocol_handle_throttle_configure(host, peer, command)) {
+                        goto commandError;
+                    }
+                    break;
+
+                case ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE_FRAGMENT:
+                    if (enet_protocol_handle_send_unreliable_fragment(host, peer, command, &currentData)) {
+                        goto commandError;
+                    }
+                    break;
+
+                default:
+                    goto commandError;
+            }
+
+            if (peer != NULL && (command->header.command & ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE) != 0) {
+                enet_uint16 sentTime;
+
+                if (!(flags & ENET_PROTOCOL_HEADER_FLAG_SENT_TIME)) {
+                    break;
+                }
+
+                sentTime = ENET_NET_TO_HOST_16(header->sentTime);
+
+                switch (peer->state) {
+                    case ENET_PEER_STATE_DISCONNECTING:
+                    case ENET_PEER_STATE_ACKNOWLEDGING_CONNECT:
+                    case ENET_PEER_STATE_DISCONNECTED:
+                    case ENET_PEER_STATE_ZOMBIE:
+                        break;
+
+                    case ENET_PEER_STATE_ACKNOWLEDGING_DISCONNECT:
+                        if ((command->header.command & ENET_PROTOCOL_COMMAND_MASK) == ENET_PROTOCOL_COMMAND_DISCONNECT) {
+                            enet_peer_queue_acknowledgement(peer, command, sentTime);
+                        }
+                        break;
+
+                    default:
+                        enet_peer_queue_acknowledgement(peer, command, sentTime);
+                        break;
+                }
+            }
+        }
+
+    commandError:
+        if (event != NULL && event->type != ENET_EVENT_TYPE_NONE) {
+            return 1;
+        }
+
+        return 0;
+    }
+
+    static int enet_protocol_receive_incoming_commands(ENetHost *host, ENetEvent *event) {
+        int packets;
+
+        for (packets = 0; packets < 256; ++packets) {
+            int receivedLength;
+            ENetBuffer buffer;
+
+            buffer.data       = host->packetData[0];
+            buffer.dataLength = host->mtu;
+
+            receivedLength    = enet_socket_receive(host->socket, &host->receivedAddress, &buffer, 1);
+
+            if (receivedLength == -2)
+                continue;
+
+            if (receivedLength < 0) {
+                return -1;
+            }
+
+            if (receivedLength == 0) {
+                return 0;
+            }
+
+            host->receivedData       = host->packetData[0];
+            host->receivedDataLength = receivedLength;
+
+            host->totalReceivedData += receivedLength;
+            host->totalReceivedPackets++;
+
+            if (host->interceptCallback != NULL) {
+                switch (host->interceptCallback(host, (void *)event)) {
+                    case 1:
+                        if (event != NULL && event->type != ENET_EVENT_TYPE_NONE) {
+                            return 1;
+                        }
+
+                        continue;
+
+                    case -1:
+                        return -1;
+
+                    default:
+                        break;
+                }
+            }
+
+            switch (enet_protocol_handle_incoming_commands(host, event)) {
+                case 1:
+                    return 1;
+
+                case -1:
+                    return -1;
+
+                default:
+                    break;
+            }
+        }
+
+        return -1;
+    }
+
+    static void enet_protocol_send_acknowledgements(ENetHost *host, ENetPeer *peer) {
+        ENetProtocol *command = &host->commands[host->commandCount];
+        ENetBuffer *buffer    = &host->buffers[host->bufferCount];
+        ENetAcknowledgement *acknowledgement;
+        ENetListIterator currentAcknowledgement;
+        enet_uint16 reliableSequenceNumber;
+
+        currentAcknowledgement = enet_list_begin(&peer->acknowledgements);
+
+        while (currentAcknowledgement != enet_list_end(&peer->acknowledgements)) {
+            if (command >= &host->commands[sizeof(host->commands) / sizeof(ENetProtocol)] ||
+                buffer >= &host->buffers[sizeof(host->buffers) / sizeof(ENetBuffer)] ||
+                peer->mtu - host->packetSize < sizeof(ENetProtocolAcknowledge)
+            ) {
+                host->continueSending = 1;
+                break;
+            }
+
+            acknowledgement = (ENetAcknowledgement *)currentAcknowledgement;
+            currentAcknowledgement = enet_list_next(currentAcknowledgement);
+
+            buffer->data       = command;
+            buffer->dataLength = sizeof(ENetProtocolAcknowledge);
+            host->packetSize += buffer->dataLength;
+
+            reliableSequenceNumber = ENET_HOST_TO_NET_16(acknowledgement->command.header.reliableSequenceNumber);
+
+            command->header.command   = ENET_PROTOCOL_COMMAND_ACKNOWLEDGE;
+            command->header.channelID = acknowledgement->command.header.channelID;
+            command->header.reliableSequenceNumber = reliableSequenceNumber;
+            command->acknowledge.receivedReliableSequenceNumber = reliableSequenceNumber;
+            command->acknowledge.receivedSentTime = ENET_HOST_TO_NET_16(acknowledgement->sentTime);
+
+            if ((acknowledgement->command.header.command & ENET_PROTOCOL_COMMAND_MASK) == ENET_PROTOCOL_COMMAND_DISCONNECT) {
+                enet_protocol_dispatch_state(host, peer, ENET_PEER_STATE_ZOMBIE);
+            }
+
+            enet_list_remove(&acknowledgement->acknowledgementList);
+            enet_free(acknowledgement);
+
+            ++command;
+            ++buffer;
+        }
+
+        host->commandCount = command - host->commands;
+        host->bufferCount  = buffer - host->buffers;
+    }
+
+    static void enet_protocol_send_unreliable_outgoing_commands(ENetHost *host, ENetPeer *peer) {
+        ENetProtocol *command = &host->commands[host->commandCount];
+        ENetBuffer *buffer    = &host->buffers[host->bufferCount];
+        ENetOutgoingCommand *outgoingCommand;
+        ENetListIterator currentCommand;
+
+        currentCommand = enet_list_begin(&peer->outgoingUnreliableCommands);
+        while (currentCommand != enet_list_end(&peer->outgoingUnreliableCommands)) {
+            size_t commandSize;
+
+            outgoingCommand = (ENetOutgoingCommand *)currentCommand;
+            commandSize     = commandSizes[outgoingCommand->command.header.command & ENET_PROTOCOL_COMMAND_MASK];
+
+            if (command >= &host->commands[sizeof(host->commands) / sizeof(ENetProtocol)] ||
+                buffer + 1 >= &host->buffers[sizeof(host->buffers) / sizeof(ENetBuffer)] ||
+                peer->mtu - host->packetSize < commandSize ||
+                (outgoingCommand->packet != NULL &&
+                peer->mtu - host->packetSize < commandSize + outgoingCommand->fragmentLength)
+            ) {
+                host->continueSending = 1;
+                break;
+            }
+
+            currentCommand = enet_list_next(currentCommand);
+
+            if (outgoingCommand->packet != NULL && outgoingCommand->fragmentOffset == 0) {
+                peer->packetThrottleCounter += ENET_PEER_PACKET_THROTTLE_COUNTER;
+                peer->packetThrottleCounter %= ENET_PEER_PACKET_THROTTLE_SCALE;
+
+                if (peer->packetThrottleCounter > peer->packetThrottle) {
+                    enet_uint16 reliableSequenceNumber = outgoingCommand->reliableSequenceNumber;
+                    enet_uint16 unreliableSequenceNumber = outgoingCommand->unreliableSequenceNumber;
+
+                    for (;;) {
+                        --outgoingCommand->packet->referenceCount;
+
+                        if (outgoingCommand->packet->referenceCount == 0) {
+                            enet_packet_destroy(outgoingCommand->packet);
+                        }
+
+                        enet_list_remove(&outgoingCommand->outgoingCommandList);
+                        enet_free(outgoingCommand);
+
+                        if (currentCommand == enet_list_end(&peer->outgoingUnreliableCommands)) {
+                            break;
+                        }
+
+                        outgoingCommand = (ENetOutgoingCommand *)currentCommand;
+
+                        if (outgoingCommand->reliableSequenceNumber != reliableSequenceNumber || outgoingCommand->unreliableSequenceNumber != unreliableSequenceNumber) {
+                            break;
+                        }
+
+                        currentCommand = enet_list_next(currentCommand);
+                    }
+
+                    continue;
+                }
+            }
+
+            buffer->data       = command;
+            buffer->dataLength = commandSize;
+            host->packetSize += buffer->dataLength;
+            *command = outgoingCommand->command;
+            enet_list_remove(&outgoingCommand->outgoingCommandList);
+
+            if (outgoingCommand->packet != NULL) {
+                ++buffer;
+
+                buffer->data       = outgoingCommand->packet->data + outgoingCommand->fragmentOffset;
+                buffer->dataLength = outgoingCommand->fragmentLength;
+
+                host->packetSize += buffer->dataLength;
+
+                enet_list_insert(enet_list_end(&peer->sentUnreliableCommands), outgoingCommand);
+            } else {
+                enet_free(outgoingCommand);
+            }
+
+            ++command;
+            ++buffer;
+        }
+
+        host->commandCount = command - host->commands;
+        host->bufferCount  = buffer - host->buffers;
+
+        if (peer->state == ENET_PEER_STATE_DISCONNECT_LATER &&
+          enet_list_empty(&peer->outgoingReliableCommands) &&
+          enet_list_empty(&peer->outgoingUnreliableCommands) &&
+          enet_list_empty(&peer->sentReliableCommands))
+        {
+            enet_peer_disconnect(peer, peer->eventData);
+        }
+    }
+
+    static int enet_protocol_check_timeouts(ENetHost *host, ENetPeer *peer, ENetEvent *event) {
+        ENetOutgoingCommand *outgoingCommand;
+        ENetListIterator currentCommand, insertPosition;
+
+        currentCommand = enet_list_begin(&peer->sentReliableCommands);
+        insertPosition = enet_list_begin(&peer->outgoingReliableCommands);
+
+        while (currentCommand != enet_list_end(&peer->sentReliableCommands)) {
+            outgoingCommand = (ENetOutgoingCommand *)currentCommand;
+
+            currentCommand = enet_list_next(currentCommand);
+
+            if (ENET_TIME_DIFFERENCE(host->serviceTime, outgoingCommand->sentTime) < outgoingCommand->roundTripTimeout) {
+                continue;
+            }
+
+            if (peer->earliestTimeout == 0 || ENET_TIME_LESS(outgoingCommand->sentTime, peer->earliestTimeout)) {
+                peer->earliestTimeout = outgoingCommand->sentTime;
+            }
+
+            if (peer->earliestTimeout != 0 &&
+                (ENET_TIME_DIFFERENCE(host->serviceTime, peer->earliestTimeout) >= peer->timeoutMaximum ||
+                (outgoingCommand->roundTripTimeout >= outgoingCommand->roundTripTimeoutLimit &&
+                ENET_TIME_DIFFERENCE(host->serviceTime, peer->earliestTimeout) >= peer->timeoutMinimum))
+            ) {
+                enet_protocol_notify_disconnect_timeout(host, peer, event);
+                return 1;
+            }
+
+            if (outgoingCommand->packet != NULL) {
+                peer->reliableDataInTransit -= outgoingCommand->fragmentLength;
+            }
+
+            ++peer->packetsLost;
+            ++peer->totalPacketsLost;
+
+            outgoingCommand->roundTripTimeout = peer->roundTripTime + 4 * peer->roundTripTimeVariance;
+            outgoingCommand->roundTripTimeoutLimit = peer->timeoutLimit * outgoingCommand->roundTripTimeout;
+
+            enet_list_insert(insertPosition, enet_list_remove(&outgoingCommand->outgoingCommandList));
+
+            if (currentCommand == enet_list_begin(&peer->sentReliableCommands) && !enet_list_empty(&peer->sentReliableCommands)) {
+                outgoingCommand = (ENetOutgoingCommand *)currentCommand;
+                peer->nextTimeout = outgoingCommand->sentTime + outgoingCommand->roundTripTimeout;
+            }
+        }
+
+        return 0;
+    }
+
+    static int enet_protocol_send_reliable_outgoing_commands(ENetHost *host, ENetPeer *peer) {
+        ENetProtocol *command = &host->commands[host->commandCount];
+        ENetBuffer *buffer    = &host->buffers[host->bufferCount];
+        ENetOutgoingCommand *outgoingCommand;
+        ENetListIterator currentCommand;
+        ENetChannel *channel;
+        enet_uint16 reliableWindow;
+        size_t commandSize;
+        int windowExceeded = 0, windowWrap = 0, canPing = 1;
+
+        currentCommand = enet_list_begin(&peer->outgoingReliableCommands);
+
+        while (currentCommand != enet_list_end(&peer->outgoingReliableCommands)) {
+            outgoingCommand = (ENetOutgoingCommand *)currentCommand;
+            channel = outgoingCommand->command.header.channelID < peer->channelCount ? &peer->channels[outgoingCommand->command.header.channelID] : NULL;
+            reliableWindow = outgoingCommand->reliableSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE;
+
+            if (channel != NULL) {
+                if (!windowWrap &&
+                    outgoingCommand->sendAttempts < 1 &&
+                    !(outgoingCommand->reliableSequenceNumber % ENET_PEER_RELIABLE_WINDOW_SIZE) &&
+                    (channel->reliableWindows[(reliableWindow + ENET_PEER_RELIABLE_WINDOWS - 1)
+                    % ENET_PEER_RELIABLE_WINDOWS] >= ENET_PEER_RELIABLE_WINDOW_SIZE ||
+                    channel->usedReliableWindows & ((((1 << ENET_PEER_FREE_RELIABLE_WINDOWS) - 1) << reliableWindow)
+                    | (((1 << ENET_PEER_FREE_RELIABLE_WINDOWS) - 1) >> (ENET_PEER_RELIABLE_WINDOWS - reliableWindow))))
+                ) {
+                    windowWrap = 1;
+                }
+
+                if (windowWrap) {
+                    currentCommand = enet_list_next(currentCommand);
+
+                    continue;
+                }
+            }
+
+            if (outgoingCommand->packet != NULL) {
+                if (!windowExceeded) {
+                    enet_uint32 windowSize = (peer->packetThrottle * peer->windowSize) / ENET_PEER_PACKET_THROTTLE_SCALE;
+
+                    if (peer->reliableDataInTransit + outgoingCommand->fragmentLength > ENET_MAX(windowSize, peer->mtu)) {
+                        windowExceeded = 1;
+                    }
+                }
+
+                if (windowExceeded) {
+                    currentCommand = enet_list_next(currentCommand);
+
+                    continue;
+                }
+            }
+
+            canPing = 0;
+
+            commandSize = commandSizes[outgoingCommand->command.header.command & ENET_PROTOCOL_COMMAND_MASK];
+
+            if (command >= &host->commands[sizeof(host->commands) / sizeof(ENetProtocol)] ||
+                buffer + 1 >= &host->buffers[sizeof(host->buffers) / sizeof(ENetBuffer)] ||
+                peer->mtu - host->packetSize < commandSize ||
+                (outgoingCommand->packet != NULL &&
+                (enet_uint16) (peer->mtu - host->packetSize) < (enet_uint16) (commandSize + outgoingCommand->fragmentLength))
+            ) {
+                host->continueSending = 1;
+                break;
+            }
+
+            currentCommand = enet_list_next(currentCommand);
+
+            if (channel != NULL && outgoingCommand->sendAttempts < 1) {
+                channel->usedReliableWindows |= 1 << reliableWindow;
+                ++channel->reliableWindows[reliableWindow];
+            }
+
+            ++outgoingCommand->sendAttempts;
+
+            if (outgoingCommand->roundTripTimeout == 0) {
+                outgoingCommand->roundTripTimeout      = peer->roundTripTime + 4 * peer->roundTripTimeVariance;
+                outgoingCommand->roundTripTimeoutLimit = peer->timeoutLimit * outgoingCommand->roundTripTimeout;
+            }
+
+            if (enet_list_empty(&peer->sentReliableCommands)) {
+                peer->nextTimeout = host->serviceTime + outgoingCommand->roundTripTimeout;
+            }
+
+            enet_list_insert(enet_list_end(&peer->sentReliableCommands), enet_list_remove(&outgoingCommand->outgoingCommandList));
+
+            outgoingCommand->sentTime = host->serviceTime;
+
+            buffer->data       = command;
+            buffer->dataLength = commandSize;
+
+            host->packetSize  += buffer->dataLength;
+            host->headerFlags |= ENET_PROTOCOL_HEADER_FLAG_SENT_TIME;
+
+            *command = outgoingCommand->command;
+
+            if (outgoingCommand->packet != NULL) {
+                ++buffer;
+                buffer->data       = outgoingCommand->packet->data + outgoingCommand->fragmentOffset;
+                buffer->dataLength = outgoingCommand->fragmentLength;
+                host->packetSize += outgoingCommand->fragmentLength;
+                peer->reliableDataInTransit += outgoingCommand->fragmentLength;
+            }
+
+            ++peer->packetsSent;
+            ++peer->totalPacketsSent;
+
+            ++command;
+            ++buffer;
+        }
+
+        host->commandCount = command - host->commands;
+        host->bufferCount  = buffer - host->buffers;
+
+        return canPing;
+    }
+
+    static int enet_protocol_send_outgoing_commands(ENetHost *host, ENetEvent *event, int checkForTimeouts) {
+        enet_uint8 headerData[sizeof(ENetProtocolHeader) + sizeof(enet_uint32)];
+        ENetProtocolHeader *header = (ENetProtocolHeader *)headerData;
+        ENetPeer *currentPeer;
+        int sentLength;
+        host->continueSending = 1;
+
+        while (host->continueSending)
+            for (host->continueSending = 0, currentPeer = host->peers; currentPeer < &host->peers[host->peerCount]; ++currentPeer) {
+                if (currentPeer->state == ENET_PEER_STATE_DISCONNECTED || currentPeer->state == ENET_PEER_STATE_ZOMBIE) {
+                    continue;
+                }
+
+                host->headerFlags  = 0;
+                host->commandCount = 0;
+                host->bufferCount  = 1;
+                host->packetSize   = sizeof(ENetProtocolHeader);
+
+                if (!enet_list_empty(&currentPeer->acknowledgements)) {
+                    enet_protocol_send_acknowledgements(host, currentPeer);
+                }
+
+                if (checkForTimeouts != 0 &&
+                    !enet_list_empty(&currentPeer->sentReliableCommands) &&
+                    ENET_TIME_GREATER_EQUAL(host->serviceTime, currentPeer->nextTimeout) &&
+                    enet_protocol_check_timeouts(host, currentPeer, event) == 1
+                ) {
+                    if (event != NULL && event->type != ENET_EVENT_TYPE_NONE) {
+                        return 1;
+                    } else {
+                        continue;
+                    }
+                }
+
+                if ((enet_list_empty(&currentPeer->outgoingReliableCommands) ||
+                    enet_protocol_send_reliable_outgoing_commands(host, currentPeer)) &&
+                    enet_list_empty(&currentPeer->sentReliableCommands) &&
+                    ENET_TIME_DIFFERENCE(host->serviceTime, currentPeer->lastReceiveTime) >= currentPeer->pingInterval &&
+                    currentPeer->mtu - host->packetSize >= sizeof(ENetProtocolPing)
+                ) {
+                    enet_peer_ping(currentPeer);
+                    enet_protocol_send_reliable_outgoing_commands(host, currentPeer);
+                }
+
+                if (!enet_list_empty(&currentPeer->outgoingUnreliableCommands)) {
+                    enet_protocol_send_unreliable_outgoing_commands(host, currentPeer);
+                }
+
+                if (host->commandCount == 0) {
+                    continue;
+                }
+
+                if (currentPeer->packetLossEpoch == 0) {
+                    currentPeer->packetLossEpoch = host->serviceTime;
+                } else if (ENET_TIME_DIFFERENCE(host->serviceTime, currentPeer->packetLossEpoch) >= ENET_PEER_PACKET_LOSS_INTERVAL && currentPeer->packetsSent > 0) {
+                    enet_uint32 packetLoss = currentPeer->packetsLost * ENET_PEER_PACKET_LOSS_SCALE / currentPeer->packetsSent;
+
+                    #ifdef ENET_DEBUG
+                        printf(
+                            "peer %u: %f%%+-%f%% packet loss, %u+-%u ms round trip time, %f%% throttle, %u/%u outgoing, %u/%u incoming\n", currentPeer->incomingPeerID,
+                            currentPeer->packetLoss / (float) ENET_PEER_PACKET_LOSS_SCALE,
+                            currentPeer->packetLossVariance / (float) ENET_PEER_PACKET_LOSS_SCALE, currentPeer->roundTripTime, currentPeer->roundTripTimeVariance,
+                            currentPeer->packetThrottle / (float) ENET_PEER_PACKET_THROTTLE_SCALE,
+                            enet_list_size(&currentPeer->outgoingReliableCommands),
+                            enet_list_size(&currentPeer->outgoingUnreliableCommands),
+                            currentPeer->channels != NULL ? enet_list_size( &currentPeer->channels->incomingReliableCommands) : 0,
+                            currentPeer->channels != NULL ? enet_list_size(&currentPeer->channels->incomingUnreliableCommands) : 0
+                        );
+                    #endif
+
+                    currentPeer->packetLossVariance -= currentPeer->packetLossVariance / 4;
+
+                    if (packetLoss >= currentPeer->packetLoss) {
+                        currentPeer->packetLoss         += (packetLoss - currentPeer->packetLoss) / 8;
+                        currentPeer->packetLossVariance += (packetLoss - currentPeer->packetLoss) / 4;
+                    } else {
+                        currentPeer->packetLoss         -= (currentPeer->packetLoss - packetLoss) / 8;
+                        currentPeer->packetLossVariance += (currentPeer->packetLoss - packetLoss) / 4;
+                    }
+
+                    currentPeer->packetLossEpoch = host->serviceTime;
+                    currentPeer->packetsSent     = 0;
+                    currentPeer->packetsLost     = 0;
+                }
+
+                host->buffers->data = headerData;
+
+                if (host->headerFlags & ENET_PROTOCOL_HEADER_FLAG_SENT_TIME) {
+                    header->sentTime = ENET_HOST_TO_NET_16(host->serviceTime & 0xFFFF);
+                    host->buffers->dataLength = sizeof(ENetProtocolHeader);
+                } else {
+                    host->buffers->dataLength = (size_t) &((ENetProtocolHeader *)0)->sentTime;
+                }
+
+                if (currentPeer->outgoingPeerID < ENET_PROTOCOL_MAXIMUM_PEER_ID) {
+                    host->headerFlags |= currentPeer->outgoingSessionID << ENET_PROTOCOL_HEADER_SESSION_SHIFT;
+                }
+
+                header->peerID = ENET_HOST_TO_NET_16(currentPeer->outgoingPeerID | host->headerFlags);
+
+                if (host->checksum != NULL) {
+                    enet_uint32 *checksum = (enet_uint32 *)&headerData[host->buffers->dataLength];
+                    *checksum = currentPeer->outgoingPeerID < ENET_PROTOCOL_MAXIMUM_PEER_ID ? currentPeer->connectID : 0;
+                    host->buffers->dataLength += sizeof(enet_uint32);
+                    *checksum = host->checksum(host->buffers, host->bufferCount);
+                }
+
+                currentPeer->lastSendTime = host->serviceTime;
+                sentLength = enet_socket_send(host->socket, &currentPeer->address, host->buffers, host->bufferCount);
+                enet_protocol_remove_sent_unreliable_commands(currentPeer);
+
+                if (sentLength < 0) {
+                    return -1;
+                }
+
+                host->totalSentData += sentLength;
+                currentPeer->totalDataSent += sentLength;
+                host->totalSentPackets++;
+            }
+
+        return 0;
+    }
+
+    void enet_host_flush(ENetHost *host) {
+        host->serviceTime = enet_time_get();
+        enet_protocol_send_outgoing_commands(host, NULL, 0);
+    }
+
+    int enet_host_check_events(ENetHost *host, ENetEvent *event) {
+        if (event == NULL) {
+            return -1;
+        }
+
+        event->type   = ENET_EVENT_TYPE_NONE;
+        event->peer   = NULL;
+        event->packet = NULL;
+
+        return enet_protocol_dispatch_incoming_commands(host, event);
+    }
+
+    int enet_host_service(ENetHost *host, ENetEvent *event, enet_uint32 timeout) {
+        enet_uint32 waitCondition;
+
+        if (event != NULL) {
+            event->type   = ENET_EVENT_TYPE_NONE;
+            event->peer   = NULL;
+            event->packet = NULL;
+
+            switch (enet_protocol_dispatch_incoming_commands(host, event)) {
+                case 1:
+                    return 1;
+
+                case -1:
+                    #ifdef ENET_DEBUG
+                        perror("Error dispatching incoming packets");
+                    #endif
+
+                    return -1;
+
+                default:
+                    break;
+            }
+        }
+
+        host->serviceTime = enet_time_get();
+        timeout += host->serviceTime;
+
+        do {
+            if (ENET_TIME_DIFFERENCE(host->serviceTime, host->bandwidthThrottleEpoch) >= ENET_HOST_BANDWIDTH_THROTTLE_INTERVAL) {
+                enet_host_bandwidth_throttle(host);
+            }
+
+            switch (enet_protocol_send_outgoing_commands(host, event, 1)) {
+                case 1:
+                    return 1;
+
+                case -1:
+                    #ifdef ENET_DEBUG
+                        perror("Error sending outgoing packets");
+                    #endif
+
+                    return -1;
+
+                default:
+                    break;
+            }
+
+            switch (enet_protocol_receive_incoming_commands(host, event)) {
+                case 1:
+                    return 1;
+
+                case -1:
+                    #ifdef ENET_DEBUG
+                        perror("Error receiving incoming packets");
+                    #endif
+
+                    return -1;
+
+                default:
+                    break;
+            }
+
+            switch (enet_protocol_send_outgoing_commands(host, event, 1)) {
+                case 1:
+                    return 1;
+
+                case -1:
+                    #ifdef ENET_DEBUG
+                        perror("Error sending outgoing packets");
+                    #endif
+
+                    return -1;
+
+                default:
+                    break;
+            }
+
+            if (event != NULL) {
+                switch (enet_protocol_dispatch_incoming_commands(host, event)) {
+                    case 1:
+                        return 1;
+
+                    case -1:
+                        #ifdef ENET_DEBUG
+                            perror("Error dispatching incoming packets");
+                        #endif
+
+                        return -1;
+
+                    default:
+                        break;
+                }
+            }
+
+            if (ENET_TIME_GREATER_EQUAL(host->serviceTime, timeout)) {
+                return 0;
+            }
+
+            do {
+                host->serviceTime = enet_time_get();
+
+                if (ENET_TIME_GREATER_EQUAL(host->serviceTime, timeout)) {
+                    return 0;
+                }
+
+                waitCondition = ENET_SOCKET_WAIT_RECEIVE | ENET_SOCKET_WAIT_INTERRUPT;
+
+                if (enet_socket_wait(host->socket, &waitCondition, ENET_TIME_DIFFERENCE(timeout, host->serviceTime)) != 0) {
+                    return -1;
+                }
+            } while (waitCondition & ENET_SOCKET_WAIT_INTERRUPT);
+
+            host->serviceTime = enet_time_get();
+        } while (waitCondition & ENET_SOCKET_WAIT_RECEIVE);
+
+        return 0;
+    }
+
+// =======================================================================//
+// !
+// ! Peer
+// !
+// =======================================================================//
+
+    void enet_peer_throttle_configure(ENetPeer *peer, enet_uint32 interval, enet_uint32 acceleration, enet_uint32 deceleration) {
+        ENetProtocol command;
+
+        peer->packetThrottleInterval     = interval;
+        peer->packetThrottleAcceleration = acceleration;
+        peer->packetThrottleDeceleration = deceleration;
+
+        command.header.command   = ENET_PROTOCOL_COMMAND_THROTTLE_CONFIGURE | ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE;
+        command.header.channelID = 0xFF;
+
+        command.throttleConfigure.packetThrottleInterval     = ENET_HOST_TO_NET_32(interval);
+        command.throttleConfigure.packetThrottleAcceleration = ENET_HOST_TO_NET_32(acceleration);
+        command.throttleConfigure.packetThrottleDeceleration = ENET_HOST_TO_NET_32(deceleration);
+
+        enet_peer_queue_outgoing_command(peer, &command, NULL, 0, 0);
+    }
+
+    int enet_peer_throttle(ENetPeer *peer, enet_uint32 rtt) {
+        if (peer->lastRoundTripTime <= peer->lastRoundTripTimeVariance) {
+            peer->packetThrottle = peer->packetThrottleLimit;
+        } else if (rtt < peer->lastRoundTripTime) {
+            peer->packetThrottle += peer->packetThrottleAcceleration;
+
+            if (peer->packetThrottle > peer->packetThrottleLimit) {
+                peer->packetThrottle = peer->packetThrottleLimit;
+            }
+
+            return 1;
+        } else if (rtt > peer->lastRoundTripTime + 2 * peer->lastRoundTripTimeVariance) {
+            if (peer->packetThrottle > peer->packetThrottleDeceleration) {
+                peer->packetThrottle -= peer->packetThrottleDeceleration;
+            } else {
+                peer->packetThrottle = 0;
+            }
+
+            return -1;
+        }
+
+        return 0;
+    }
+
+    int enet_peer_send(ENetPeer *peer, enet_uint8 channelID, ENetPacket *packet) {
+        ENetChannel *channel = &peer->channels[channelID];
+        ENetProtocol command;
+        size_t fragmentLength;
+
+        if (peer->state != ENET_PEER_STATE_CONNECTED || channelID >= peer->channelCount || packet->dataLength > peer->host->maximumPacketSize) {
+            return -1;
+        }
+
+        fragmentLength = peer->mtu - sizeof(ENetProtocolHeader) - sizeof(ENetProtocolSendFragment);
+
+        if (peer->host->checksum != NULL) {
+            fragmentLength -= sizeof(enet_uint32);
+        }
+
+        if (packet->dataLength > fragmentLength) {
+            enet_uint32 fragmentCount = (packet->dataLength + fragmentLength - 1) / fragmentLength, fragmentNumber, fragmentOffset;
+            enet_uint8 commandNumber;
+            enet_uint16 startSequenceNumber;
+            ENetList fragments;
+            ENetOutgoingCommand *fragment;
+
+            if (fragmentCount > ENET_PROTOCOL_MAXIMUM_FRAGMENT_COUNT) {
+                return -1;
+            }
+
+            if ((packet->flags & (ENET_PACKET_FLAG_RELIABLE | ENET_PACKET_FLAG_UNRELIABLE_FRAGMENT)) == ENET_PACKET_FLAG_UNRELIABLE_FRAGMENT && channel->outgoingUnreliableSequenceNumber < 0xFFFF) {
+                commandNumber       = ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE_FRAGMENT;
+                startSequenceNumber = ENET_HOST_TO_NET_16(channel->outgoingUnreliableSequenceNumber + 1);
+            } else {
+                commandNumber       = ENET_PROTOCOL_COMMAND_SEND_FRAGMENT | ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE;
+                startSequenceNumber = ENET_HOST_TO_NET_16(channel->outgoingReliableSequenceNumber + 1);
+            }
+
+            enet_list_clear(&fragments);
+
+            for (fragmentNumber = 0, fragmentOffset = 0; fragmentOffset < packet->dataLength; ++fragmentNumber, fragmentOffset += fragmentLength) {
+                if (packet->dataLength - fragmentOffset < fragmentLength) {
+                    fragmentLength = packet->dataLength - fragmentOffset;
+                }
+
+                fragment = (ENetOutgoingCommand *)enet_malloc(sizeof(ENetOutgoingCommand));
+
+                if (fragment == NULL) {
+                    while (!enet_list_empty(&fragments)) {
+                        fragment = (ENetOutgoingCommand *)enet_list_remove(enet_list_begin(&fragments));
+
+                        enet_free(fragment);
+                    }
+
+                    return -1;
+                }
+
+                fragment->fragmentOffset           = fragmentOffset;
+                fragment->fragmentLength           = fragmentLength;
+                fragment->packet                   = packet;
+                fragment->command.header.command   = commandNumber;
+                fragment->command.header.channelID = channelID;
+
+                fragment->command.sendFragment.startSequenceNumber = startSequenceNumber;
+
+                fragment->command.sendFragment.dataLength     = ENET_HOST_TO_NET_16(fragmentLength);
+                fragment->command.sendFragment.fragmentCount  = ENET_HOST_TO_NET_32(fragmentCount);
+                fragment->command.sendFragment.fragmentNumber = ENET_HOST_TO_NET_32(fragmentNumber);
+                fragment->command.sendFragment.totalLength    = ENET_HOST_TO_NET_32(packet->dataLength);
+                fragment->command.sendFragment.fragmentOffset = ENET_NET_TO_HOST_32(fragmentOffset);
+
+                enet_list_insert(enet_list_end(&fragments), fragment);
+            }
+
+            packet->referenceCount += fragmentNumber;
+
+            while (!enet_list_empty(&fragments)) {
+                fragment = (ENetOutgoingCommand *)enet_list_remove(enet_list_begin(&fragments));
+                enet_peer_setup_outgoing_command(peer, fragment);
+            }
+
+            return 0;
+        }
+
+        command.header.channelID = channelID;
+
+        if ((packet->flags & (ENET_PACKET_FLAG_RELIABLE | ENET_PACKET_FLAG_UNSEQUENCED)) == ENET_PACKET_FLAG_UNSEQUENCED) {
+            command.header.command = ENET_PROTOCOL_COMMAND_SEND_UNSEQUENCED | ENET_PROTOCOL_COMMAND_FLAG_UNSEQUENCED;
+            command.sendUnsequenced.dataLength = ENET_HOST_TO_NET_16(packet->dataLength);
+        } else if (packet->flags & ENET_PACKET_FLAG_RELIABLE || channel->outgoingUnreliableSequenceNumber >= 0xFFFF) {
+            command.header.command = ENET_PROTOCOL_COMMAND_SEND_RELIABLE | ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE;
+            command.sendReliable.dataLength = ENET_HOST_TO_NET_16(packet->dataLength);
+        } else {
+            command.header.command = ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE;
+            command.sendUnreliable.dataLength = ENET_HOST_TO_NET_16(packet->dataLength);
+        }
+
+        if (enet_peer_queue_outgoing_command(peer, &command, packet, 0, packet->dataLength) == NULL) {
+            return -1;
+        }
+
+        return 0;
+    }
+
+    ENetPacket * enet_peer_receive(ENetPeer *peer, enet_uint8 *channelID) {
+        ENetIncomingCommand *incomingCommand;
+        ENetPacket *packet;
+
+        if (enet_list_empty(&peer->dispatchedCommands)) {
+            return NULL;
+        }
+
+        incomingCommand = (ENetIncomingCommand *)enet_list_remove(enet_list_begin(&peer->dispatchedCommands));
+
+        if (channelID != NULL) {
+            *channelID = incomingCommand->command.header.channelID;
+        }
+
+        packet = incomingCommand->packet;
+        --packet->referenceCount;
+
+        if (incomingCommand->fragments != NULL) {
+            enet_free(incomingCommand->fragments);
+        }
+
+        enet_free(incomingCommand);
+        peer->totalWaitingData -= packet->dataLength;
+
+        return packet;
+    }
+
+    static void enet_peer_reset_outgoing_commands(ENetList *queue) {
+        ENetOutgoingCommand *outgoingCommand;
+
+        while (!enet_list_empty(queue)) {
+            outgoingCommand = (ENetOutgoingCommand *)enet_list_remove(enet_list_begin(queue));
+
+            if (outgoingCommand->packet != NULL) {
+                --outgoingCommand->packet->referenceCount;
+
+                if (outgoingCommand->packet->referenceCount == 0) {
+                    enet_packet_destroy(outgoingCommand->packet);
+                }
+            }
+
+            enet_free(outgoingCommand);
+        }
+    }
+
+    static void enet_peer_remove_incoming_commands(ENetList *queue, ENetListIterator startCommand, ENetListIterator endCommand) {
+        ENetListIterator currentCommand;
+
+        for (currentCommand = startCommand; currentCommand != endCommand;) {
+            ENetIncomingCommand *incomingCommand = (ENetIncomingCommand *)currentCommand;
+
+            currentCommand = enet_list_next(currentCommand);
+            enet_list_remove(&incomingCommand->incomingCommandList);
+
+            if (incomingCommand->packet != NULL) {
+                --incomingCommand->packet->referenceCount;
+
+                if (incomingCommand->packet->referenceCount == 0) {
+                    enet_packet_destroy(incomingCommand->packet);
+                }
+            }
+
+            if (incomingCommand->fragments != NULL) {
+                enet_free(incomingCommand->fragments);
+            }
+
+            enet_free(incomingCommand);
+        }
+    }
+
+    static void enet_peer_reset_incoming_commands(ENetList *queue) {
+        enet_peer_remove_incoming_commands(queue, enet_list_begin(queue), enet_list_end(queue));
+    }
+
+    void enet_peer_reset_queues(ENetPeer *peer) {
+        ENetChannel *channel;
+
+        if (peer->needsDispatch) {
+            enet_list_remove(&peer->dispatchList);
+            peer->needsDispatch = 0;
+        }
+
+        while (!enet_list_empty(&peer->acknowledgements)) {
+            enet_free(enet_list_remove(enet_list_begin(&peer->acknowledgements)));
+        }
+
+        enet_peer_reset_outgoing_commands(&peer->sentReliableCommands);
+        enet_peer_reset_outgoing_commands(&peer->sentUnreliableCommands);
+        enet_peer_reset_outgoing_commands(&peer->outgoingReliableCommands);
+        enet_peer_reset_outgoing_commands(&peer->outgoingUnreliableCommands);
+        enet_peer_reset_incoming_commands(&peer->dispatchedCommands);
+
+        if (peer->channels != NULL && peer->channelCount > 0) {
+            for (channel = peer->channels; channel < &peer->channels[peer->channelCount]; ++channel) {
+                enet_peer_reset_incoming_commands(&channel->incomingReliableCommands);
+                enet_peer_reset_incoming_commands(&channel->incomingUnreliableCommands);
+            }
+
+            enet_free(peer->channels);
+        }
+
+        peer->channels     = NULL;
+        peer->channelCount = 0;
+    }
+
+    void enet_peer_on_connect(ENetPeer *peer) {
+        if (peer->state != ENET_PEER_STATE_CONNECTED && peer->state != ENET_PEER_STATE_DISCONNECT_LATER) {
+            if (peer->incomingBandwidth != 0) {
+                ++peer->host->bandwidthLimitedPeers;
+            }
+
+            ++peer->host->connectedPeers;
+        }
+    }
+
+    void enet_peer_on_disconnect(ENetPeer *peer) {
+        if (peer->state == ENET_PEER_STATE_CONNECTED || peer->state == ENET_PEER_STATE_DISCONNECT_LATER) {
+            if (peer->incomingBandwidth != 0) {
+                --peer->host->bandwidthLimitedPeers;
+            }
+
+            --peer->host->connectedPeers;
+        }
+    }
+
+    void enet_peer_reset(ENetPeer *peer) {
+        enet_peer_on_disconnect(peer);
+
+        peer->outgoingPeerID                 = ENET_PROTOCOL_MAXIMUM_PEER_ID;
+        peer->state                          = ENET_PEER_STATE_DISCONNECTED;
+        peer->incomingBandwidth              = 0;
+        peer->outgoingBandwidth              = 0;
+        peer->incomingBandwidthThrottleEpoch = 0;
+        peer->outgoingBandwidthThrottleEpoch = 0;
+        peer->incomingDataTotal              = 0;
+        peer->totalDataReceived              = 0;
+        peer->outgoingDataTotal              = 0;
+        peer->totalDataSent                  = 0;
+        peer->lastSendTime                   = 0;
+        peer->lastReceiveTime                = 0;
+        peer->nextTimeout                    = 0;
+        peer->earliestTimeout                = 0;
+        peer->packetLossEpoch                = 0;
+        peer->packetsSent                    = 0;
+        peer->totalPacketsSent               = 0;
+        peer->packetsLost                    = 0;
+        peer->totalPacketsLost               = 0;
+        peer->packetLoss                     = 0;
+        peer->packetLossVariance             = 0;
+        peer->packetThrottle                 = ENET_PEER_DEFAULT_PACKET_THROTTLE;
+        peer->packetThrottleLimit            = ENET_PEER_PACKET_THROTTLE_SCALE;
+        peer->packetThrottleCounter          = 0;
+        peer->packetThrottleEpoch            = 0;
+        peer->packetThrottleAcceleration     = ENET_PEER_PACKET_THROTTLE_ACCELERATION;
+        peer->packetThrottleDeceleration     = ENET_PEER_PACKET_THROTTLE_DECELERATION;
+        peer->packetThrottleInterval         = ENET_PEER_PACKET_THROTTLE_INTERVAL;
+        peer->pingInterval                   = ENET_PEER_PING_INTERVAL;
+        peer->timeoutLimit                   = ENET_PEER_TIMEOUT_LIMIT;
+        peer->timeoutMinimum                 = ENET_PEER_TIMEOUT_MINIMUM;
+        peer->timeoutMaximum                 = ENET_PEER_TIMEOUT_MAXIMUM;
+        peer->lastRoundTripTime              = ENET_PEER_DEFAULT_ROUND_TRIP_TIME;
+        peer->lowestRoundTripTime            = ENET_PEER_DEFAULT_ROUND_TRIP_TIME;
+        peer->lastRoundTripTimeVariance      = 0;
+        peer->highestRoundTripTimeVariance   = 0;
+        peer->roundTripTime                  = ENET_PEER_DEFAULT_ROUND_TRIP_TIME;
+        peer->roundTripTimeVariance          = 0;
+        peer->mtu                            = peer->host->mtu;
+        peer->reliableDataInTransit          = 0;
+        peer->outgoingReliableSequenceNumber = 0;
+        peer->windowSize                     = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
+        peer->incomingUnsequencedGroup       = 0;
+        peer->outgoingUnsequencedGroup       = 0;
+        peer->eventData                      = 0;
+        peer->totalWaitingData               = 0;
+
+        memset(peer->unsequencedWindow, 0, sizeof(peer->unsequencedWindow));
+        enet_peer_reset_queues(peer);
+    }
+
+    void enet_peer_ping(ENetPeer *peer) {
+        ENetProtocol command;
+
+        if (peer->state != ENET_PEER_STATE_CONNECTED) {
+            return;
+        }
+
+        command.header.command   = ENET_PROTOCOL_COMMAND_PING | ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE;
+        command.header.channelID = 0xFF;
+
+        enet_peer_queue_outgoing_command(peer, &command, NULL, 0, 0);
+    }
+
+    void enet_peer_ping_interval(ENetPeer *peer, enet_uint32 pingInterval) {
+        peer->pingInterval = pingInterval ? pingInterval : ENET_PEER_PING_INTERVAL;
+    }
+
+    void enet_peer_timeout(ENetPeer *peer, enet_uint32 timeoutLimit, enet_uint32 timeoutMinimum, enet_uint32 timeoutMaximum) {
+        peer->timeoutLimit   = timeoutLimit ? timeoutLimit : ENET_PEER_TIMEOUT_LIMIT;
+        peer->timeoutMinimum = timeoutMinimum ? timeoutMinimum : ENET_PEER_TIMEOUT_MINIMUM;
+        peer->timeoutMaximum = timeoutMaximum ? timeoutMaximum : ENET_PEER_TIMEOUT_MAXIMUM;
+    }
+
+    void enet_peer_disconnect_now(ENetPeer *peer, enet_uint32 data) {
+        ENetProtocol command;
+
+        if (peer->state == ENET_PEER_STATE_DISCONNECTED) {
+            return;
+        }
+
+        if (peer->state != ENET_PEER_STATE_ZOMBIE && peer->state != ENET_PEER_STATE_DISCONNECTING) {
+            enet_peer_reset_queues(peer);
+
+            command.header.command   = ENET_PROTOCOL_COMMAND_DISCONNECT | ENET_PROTOCOL_COMMAND_FLAG_UNSEQUENCED;
+            command.header.channelID = 0xFF;
+            command.disconnect.data  = ENET_HOST_TO_NET_32(data);
+
+            enet_peer_queue_outgoing_command(peer, &command, NULL, 0, 0);
+            enet_host_flush(peer->host);
+        }
+
+        enet_peer_reset(peer);
+    }
+
+    void enet_peer_disconnect(ENetPeer *peer, enet_uint32 data) {
+        ENetProtocol command;
+
+        if (peer->state == ENET_PEER_STATE_DISCONNECTING ||
+            peer->state == ENET_PEER_STATE_DISCONNECTED ||
+            peer->state == ENET_PEER_STATE_ACKNOWLEDGING_DISCONNECT ||
+            peer->state == ENET_PEER_STATE_ZOMBIE
+        ) {
+            return;
+        }
+
+        enet_peer_reset_queues(peer);
+
+        command.header.command   = ENET_PROTOCOL_COMMAND_DISCONNECT;
+        command.header.channelID = 0xFF;
+        command.disconnect.data  = ENET_HOST_TO_NET_32(data);
+
+        if (peer->state == ENET_PEER_STATE_CONNECTED || peer->state == ENET_PEER_STATE_DISCONNECT_LATER) {
+            command.header.command |= ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE;
+        } else {
+            command.header.command |= ENET_PROTOCOL_COMMAND_FLAG_UNSEQUENCED;
+        }
+
+        enet_peer_queue_outgoing_command(peer, &command, NULL, 0, 0);
+
+        if (peer->state == ENET_PEER_STATE_CONNECTED || peer->state == ENET_PEER_STATE_DISCONNECT_LATER) {
+            enet_peer_on_disconnect(peer);
+
+            peer->state = ENET_PEER_STATE_DISCONNECTING;
+        } else {
+            enet_host_flush(peer->host);
+            enet_peer_reset(peer);
+        }
+    }
+
+    void enet_peer_disconnect_later(ENetPeer *peer, enet_uint32 data) {
+        if ((peer->state == ENET_PEER_STATE_CONNECTED || peer->state == ENET_PEER_STATE_DISCONNECT_LATER) &&
+            !(enet_list_empty(&peer->outgoingReliableCommands) &&
+            enet_list_empty(&peer->outgoingUnreliableCommands) &&
+            enet_list_empty(&peer->sentReliableCommands))
+        ) {
+            peer->state     = ENET_PEER_STATE_DISCONNECT_LATER;
+            peer->eventData = data;
+        } else {
+            enet_peer_disconnect(peer, data);
+        }
+    }
+
+    ENetAcknowledgement *enet_peer_queue_acknowledgement(ENetPeer *peer, const ENetProtocol *command, enet_uint16 sentTime) {
+        ENetAcknowledgement *acknowledgement;
+
+        if (command->header.channelID < peer->channelCount) {
+            ENetChannel *channel       = &peer->channels[command->header.channelID];
+            enet_uint16 reliableWindow = command->header.reliableSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE;
+            enet_uint16 currentWindow  = channel->incomingReliableSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE;
+
+            if (command->header.reliableSequenceNumber < channel->incomingReliableSequenceNumber) {
+                reliableWindow += ENET_PEER_RELIABLE_WINDOWS;
+            }
+
+            if (reliableWindow >= currentWindow + ENET_PEER_FREE_RELIABLE_WINDOWS - 1 && reliableWindow <= currentWindow + ENET_PEER_FREE_RELIABLE_WINDOWS) {
+                return NULL;
+            }
+        }
+
+        acknowledgement = (ENetAcknowledgement *)enet_malloc(sizeof(ENetAcknowledgement));
+
+        if (acknowledgement == NULL) {
+            return NULL;
+        }
+
+        peer->outgoingDataTotal += sizeof(ENetProtocolAcknowledge);
+
+        acknowledgement->sentTime = sentTime;
+        acknowledgement->command  = *command;
+
+        enet_list_insert(enet_list_end(&peer->acknowledgements), acknowledgement);
+
+        return acknowledgement;
+    }
+
+    void enet_peer_setup_outgoing_command(ENetPeer *peer, ENetOutgoingCommand *outgoingCommand) {
+        ENetChannel *channel = &peer->channels[outgoingCommand->command.header.channelID];
+        peer->outgoingDataTotal += enet_protocol_command_size(outgoingCommand->command.header.command) + outgoingCommand->fragmentLength;
+
+        if (outgoingCommand->command.header.channelID == 0xFF) {
+            ++peer->outgoingReliableSequenceNumber;
+
+            outgoingCommand->reliableSequenceNumber   = peer->outgoingReliableSequenceNumber;
+            outgoingCommand->unreliableSequenceNumber = 0;
+        } else if (outgoingCommand->command.header.command & ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE) {
+            ++channel->outgoingReliableSequenceNumber;
+            channel->outgoingUnreliableSequenceNumber = 0;
+
+            outgoingCommand->reliableSequenceNumber   = channel->outgoingReliableSequenceNumber;
+            outgoingCommand->unreliableSequenceNumber = 0;
+        } else if (outgoingCommand->command.header.command & ENET_PROTOCOL_COMMAND_FLAG_UNSEQUENCED) {
+            ++peer->outgoingUnsequencedGroup;
+
+            outgoingCommand->reliableSequenceNumber   = 0;
+            outgoingCommand->unreliableSequenceNumber = 0;
+        } else {
+            if (outgoingCommand->fragmentOffset == 0) {
+                ++channel->outgoingUnreliableSequenceNumber;
+            }
+
+            outgoingCommand->reliableSequenceNumber   = channel->outgoingReliableSequenceNumber;
+            outgoingCommand->unreliableSequenceNumber = channel->outgoingUnreliableSequenceNumber;
+        }
+
+        outgoingCommand->sendAttempts          = 0;
+        outgoingCommand->sentTime              = 0;
+        outgoingCommand->roundTripTimeout      = 0;
+        outgoingCommand->roundTripTimeoutLimit = 0;
+        outgoingCommand->command.header.reliableSequenceNumber = ENET_HOST_TO_NET_16(outgoingCommand->reliableSequenceNumber);
+
+        switch (outgoingCommand->command.header.command & ENET_PROTOCOL_COMMAND_MASK) {
+            case ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE:
+                outgoingCommand->command.sendUnreliable.unreliableSequenceNumber = ENET_HOST_TO_NET_16(outgoingCommand->unreliableSequenceNumber);
+                break;
+
+            case ENET_PROTOCOL_COMMAND_SEND_UNSEQUENCED:
+                outgoingCommand->command.sendUnsequenced.unsequencedGroup = ENET_HOST_TO_NET_16(peer->outgoingUnsequencedGroup);
+                break;
+
+            default:
+                break;
+        }
+
+        if (outgoingCommand->command.header.command & ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE) {
+            enet_list_insert(enet_list_end(&peer->outgoingReliableCommands), outgoingCommand);
+        } else {
+            enet_list_insert(enet_list_end(&peer->outgoingUnreliableCommands), outgoingCommand);
+        }
+    }
+
+    ENetOutgoingCommand * enet_peer_queue_outgoing_command(ENetPeer *peer, const ENetProtocol *command, ENetPacket *packet, enet_uint32 offset, enet_uint16 length) {
+        ENetOutgoingCommand *outgoingCommand = (ENetOutgoingCommand *)enet_malloc(sizeof(ENetOutgoingCommand));
+
+        if (outgoingCommand == NULL) {
+            return NULL;
+        }
+
+        outgoingCommand->command        = *command;
+        outgoingCommand->fragmentOffset = offset;
+        outgoingCommand->fragmentLength = length;
+        outgoingCommand->packet         = packet;
+
+        if (packet != NULL) {
+            ++packet->referenceCount;
+        }
+
+        enet_peer_setup_outgoing_command(peer, outgoingCommand);
+
+        return outgoingCommand;
+    }
+
+    void enet_peer_dispatch_incoming_unreliable_commands(ENetPeer *peer, ENetChannel *channel) {
+        ENetListIterator droppedCommand, startCommand, currentCommand;
+
+        for (droppedCommand = startCommand = currentCommand = enet_list_begin(&channel->incomingUnreliableCommands);
+            currentCommand != enet_list_end(&channel->incomingUnreliableCommands);
+            currentCommand = enet_list_next(currentCommand)
+        ) {
+            ENetIncomingCommand *incomingCommand = (ENetIncomingCommand *)currentCommand;
+
+            if ((incomingCommand->command.header.command & ENET_PROTOCOL_COMMAND_MASK) == ENET_PROTOCOL_COMMAND_SEND_UNSEQUENCED) {
+                continue;
+            }
+
+            if (incomingCommand->reliableSequenceNumber == channel->incomingReliableSequenceNumber) {
+                if (incomingCommand->fragmentsRemaining <= 0) {
+                    channel->incomingUnreliableSequenceNumber = incomingCommand->unreliableSequenceNumber;
+                    continue;
+                }
+
+                if (startCommand != currentCommand) {
+                    enet_list_move(enet_list_end(&peer->dispatchedCommands), startCommand, enet_list_previous(currentCommand));
+
+                    if (!peer->needsDispatch) {
+                        enet_list_insert(enet_list_end(&peer->host->dispatchQueue), &peer->dispatchList);
+                        peer->needsDispatch = 1;
+                    }
+
+                    droppedCommand = currentCommand;
+                } else if (droppedCommand != currentCommand) {
+                    droppedCommand = enet_list_previous(currentCommand);
+                }
+            } else {
+                enet_uint16 reliableWindow = incomingCommand->reliableSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE;
+                enet_uint16 currentWindow  = channel->incomingReliableSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE;
+
+                if (incomingCommand->reliableSequenceNumber < channel->incomingReliableSequenceNumber) {
+                    reliableWindow += ENET_PEER_RELIABLE_WINDOWS;
+                }
+
+                if (reliableWindow >= currentWindow && reliableWindow < currentWindow + ENET_PEER_FREE_RELIABLE_WINDOWS - 1) {
+                    break;
+                }
+
+                droppedCommand = enet_list_next(currentCommand);
+
+                if (startCommand != currentCommand) {
+                    enet_list_move(enet_list_end(&peer->dispatchedCommands), startCommand, enet_list_previous(currentCommand));
+
+                    if (!peer->needsDispatch) {
+                        enet_list_insert(enet_list_end(&peer->host->dispatchQueue), &peer->dispatchList);
+                        peer->needsDispatch = 1;
+                    }
+                }
+            }
+
+            startCommand = enet_list_next(currentCommand);
+        }
+
+        if (startCommand != currentCommand) {
+            enet_list_move(enet_list_end(&peer->dispatchedCommands), startCommand, enet_list_previous(currentCommand));
+
+            if (!peer->needsDispatch) {
+                enet_list_insert(enet_list_end(&peer->host->dispatchQueue), &peer->dispatchList);
+                peer->needsDispatch = 1;
+            }
+
+            droppedCommand = currentCommand;
+        }
+
+        enet_peer_remove_incoming_commands(&channel->incomingUnreliableCommands,enet_list_begin(&channel->incomingUnreliableCommands), droppedCommand);
+    }
+
+    void enet_peer_dispatch_incoming_reliable_commands(ENetPeer *peer, ENetChannel *channel) {
+        ENetListIterator currentCommand;
+
+        for (currentCommand = enet_list_begin(&channel->incomingReliableCommands);
+            currentCommand != enet_list_end(&channel->incomingReliableCommands);
+            currentCommand = enet_list_next(currentCommand)
+        ) {
+            ENetIncomingCommand *incomingCommand = (ENetIncomingCommand *)currentCommand;
+
+            if (incomingCommand->fragmentsRemaining > 0 || incomingCommand->reliableSequenceNumber != (enet_uint16) (channel->incomingReliableSequenceNumber + 1)) {
+                break;
+            }
+
+            channel->incomingReliableSequenceNumber = incomingCommand->reliableSequenceNumber;
+
+            if (incomingCommand->fragmentCount > 0) {
+                channel->incomingReliableSequenceNumber += incomingCommand->fragmentCount - 1;
+            }
+        }
+
+        if (currentCommand == enet_list_begin(&channel->incomingReliableCommands)) {
+            return;
+        }
+
+        channel->incomingUnreliableSequenceNumber = 0;
+        enet_list_move(enet_list_end(&peer->dispatchedCommands), enet_list_begin(&channel->incomingReliableCommands), enet_list_previous(currentCommand));
+
+        if (!peer->needsDispatch) {
+            enet_list_insert(enet_list_end(&peer->host->dispatchQueue), &peer->dispatchList);
+            peer->needsDispatch = 1;
+        }
+
+        if (!enet_list_empty(&channel->incomingUnreliableCommands)) {
+            enet_peer_dispatch_incoming_unreliable_commands(peer, channel);
+        }
+    }
+
+    ENetIncomingCommand * enet_peer_queue_incoming_command(ENetPeer *peer, const ENetProtocol *command, const void *data, size_t dataLength, enet_uint32 flags, enet_uint32 fragmentCount) {
+        static ENetIncomingCommand dummyCommand;
+
+        ENetChannel *channel = &peer->channels[command->header.channelID];
+        enet_uint32 unreliableSequenceNumber = 0, reliableSequenceNumber = 0;
+        enet_uint16 reliableWindow, currentWindow;
+        ENetIncomingCommand *incomingCommand;
+        ENetListIterator currentCommand;
+        ENetPacket *packet = NULL;
+
+        if (peer->state == ENET_PEER_STATE_DISCONNECT_LATER) {
+            goto discardCommand;
+        }
+
+        if ((command->header.command & ENET_PROTOCOL_COMMAND_MASK) != ENET_PROTOCOL_COMMAND_SEND_UNSEQUENCED) {
+            reliableSequenceNumber = command->header.reliableSequenceNumber;
+            reliableWindow         = reliableSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE;
+            currentWindow = channel->incomingReliableSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE;
+
+            if (reliableSequenceNumber < channel->incomingReliableSequenceNumber) {
+                reliableWindow += ENET_PEER_RELIABLE_WINDOWS;
+            }
+
+            if (reliableWindow < currentWindow || reliableWindow >= currentWindow + ENET_PEER_FREE_RELIABLE_WINDOWS - 1) {
+                goto discardCommand;
+            }
+        }
+
+        switch (command->header.command & ENET_PROTOCOL_COMMAND_MASK) {
+            case ENET_PROTOCOL_COMMAND_SEND_FRAGMENT:
+            case ENET_PROTOCOL_COMMAND_SEND_RELIABLE:
+                if (reliableSequenceNumber == channel->incomingReliableSequenceNumber) {
+                    goto discardCommand;
+                }
+
+                for (currentCommand = enet_list_previous(enet_list_end(&channel->incomingReliableCommands));
+                    currentCommand != enet_list_end(&channel->incomingReliableCommands);
+                    currentCommand = enet_list_previous(currentCommand)
+                ) {
+                    incomingCommand = (ENetIncomingCommand *)currentCommand;
+
+                    if (reliableSequenceNumber >= channel->incomingReliableSequenceNumber) {
+                        if (incomingCommand->reliableSequenceNumber < channel->incomingReliableSequenceNumber) {
+                            continue;
+                        }
+                    } else if (incomingCommand->reliableSequenceNumber >= channel->incomingReliableSequenceNumber) {
+                        break;
+                    }
+
+                    if (incomingCommand->reliableSequenceNumber <= reliableSequenceNumber) {
+                        if (incomingCommand->reliableSequenceNumber < reliableSequenceNumber) {
+                            break;
+                        }
+
+                        goto discardCommand;
+                    }
+                }
+                break;
+
+            case ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE:
+            case ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE_FRAGMENT:
+                unreliableSequenceNumber = ENET_NET_TO_HOST_16(command->sendUnreliable.unreliableSequenceNumber);
+
+                if (reliableSequenceNumber == channel->incomingReliableSequenceNumber && unreliableSequenceNumber <= channel->incomingUnreliableSequenceNumber) {
+                    goto discardCommand;
+                }
+
+                for (currentCommand = enet_list_previous(enet_list_end(&channel->incomingUnreliableCommands));
+                    currentCommand != enet_list_end(&channel->incomingUnreliableCommands);
+                    currentCommand = enet_list_previous(currentCommand)
+                ) {
+                    incomingCommand = (ENetIncomingCommand *)currentCommand;
+
+                    if ((command->header.command & ENET_PROTOCOL_COMMAND_MASK) == ENET_PROTOCOL_COMMAND_SEND_UNSEQUENCED) {
+                        continue;
+                    }
+
+                    if (reliableSequenceNumber >= channel->incomingReliableSequenceNumber) {
+                        if (incomingCommand->reliableSequenceNumber < channel->incomingReliableSequenceNumber) {
+                            continue;
+                        }
+                    } else if (incomingCommand->reliableSequenceNumber >= channel->incomingReliableSequenceNumber) {
+                        break;
+                    }
+
+                    if (incomingCommand->reliableSequenceNumber < reliableSequenceNumber) {
+                        break;
+                    }
+
+                    if (incomingCommand->reliableSequenceNumber > reliableSequenceNumber) {
+                        continue;
+                    }
+
+                    if (incomingCommand->unreliableSequenceNumber <= unreliableSequenceNumber) {
+                        if (incomingCommand->unreliableSequenceNumber < unreliableSequenceNumber) {
+                            break;
+                        }
+
+                        goto discardCommand;
+                    }
+                }
+                break;
+
+            case ENET_PROTOCOL_COMMAND_SEND_UNSEQUENCED:
+                currentCommand = enet_list_end(&channel->incomingUnreliableCommands);
+                break;
+
+            default:
+                goto discardCommand;
+        }
+
+        if (peer->totalWaitingData >= peer->host->maximumWaitingData) {
+            goto notifyError;
+        }
+
+        packet = enet_packet_create(data, dataLength, flags);
+
+        if (packet == NULL) {
+            goto notifyError;
+        }
+
+        incomingCommand = (ENetIncomingCommand *)enet_malloc(sizeof(ENetIncomingCommand));
+
+        if (incomingCommand == NULL) {
+            goto notifyError;
+        }
+
+        incomingCommand->reliableSequenceNumber     = command->header.reliableSequenceNumber;
+        incomingCommand->unreliableSequenceNumber   = unreliableSequenceNumber & 0xFFFF;
+        incomingCommand->command                    = *command;
+        incomingCommand->fragmentCount              = fragmentCount;
+        incomingCommand->fragmentsRemaining         = fragmentCount;
+        incomingCommand->packet                     = packet;
+        incomingCommand->fragments                  = NULL;
+
+        if (fragmentCount > 0) {
+            if (fragmentCount <= ENET_PROTOCOL_MAXIMUM_FRAGMENT_COUNT) {
+                incomingCommand->fragments = (enet_uint32 *)enet_malloc((fragmentCount + 31) / 32 * sizeof(enet_uint32));
+            }
+
+            if (incomingCommand->fragments == NULL) {
+                enet_free(incomingCommand);
+
+                goto notifyError;
+            }
+
+            memset(incomingCommand->fragments, 0, (fragmentCount + 31) / 32 * sizeof(enet_uint32));
+        }
+
+        if (packet != NULL) {
+            ++packet->referenceCount;
+            peer->totalWaitingData += packet->dataLength;
+        }
+
+        enet_list_insert(enet_list_next(currentCommand), incomingCommand);
+
+        switch (command->header.command & ENET_PROTOCOL_COMMAND_MASK) {
+            case ENET_PROTOCOL_COMMAND_SEND_FRAGMENT:
+            case ENET_PROTOCOL_COMMAND_SEND_RELIABLE:
+                enet_peer_dispatch_incoming_reliable_commands(peer, channel);
+                break;
+
+            default:
+                enet_peer_dispatch_incoming_unreliable_commands(peer, channel);
+                break;
+        }
+
+        return incomingCommand;
+
+    discardCommand:
+        if (fragmentCount > 0) {
+            goto notifyError;
+        }
+
+        if (packet != NULL && packet->referenceCount == 0) {
+            enet_packet_destroy(packet);
+        }
+
+        return &dummyCommand;
+
+    notifyError:
+        if (packet != NULL && packet->referenceCount == 0) {
+            enet_packet_destroy(packet);
+        }
+
+        return NULL;
+    }
+
+// =======================================================================//
+// !
+// ! Host
+// !
+// =======================================================================//
+
+    ENetHost * enet_host_create(const ENetAddress *address, size_t peerCount, size_t channelLimit, enet_uint32 incomingBandwidth, enet_uint32 outgoingBandwidth) {
+        ENetHost *host;
+        ENetPeer *currentPeer;
+
+        if (peerCount > ENET_PROTOCOL_MAXIMUM_PEER_ID) {
+            return NULL;
+        }
+
+        host = (ENetHost *)enet_malloc(sizeof(ENetHost));
+
+        if (host == NULL) {
+            return NULL;
+        }
+
+        memset(host, 0, sizeof(ENetHost));
+
+        host->peers = (ENetPeer *)enet_malloc(peerCount * sizeof(ENetPeer));
+
+        if (host->peers == NULL) {
+            enet_free(host);
+
+            return NULL;
+        }
+
+        memset(host->peers, 0, peerCount * sizeof(ENetPeer));
+
+        host->socket = enet_socket_create(ENET_SOCKET_TYPE_DATAGRAM);
+
+        if (host->socket != ENET_SOCKET_NULL) {
+            enet_socket_set_option (host->socket, ENET_SOCKOPT_IPV6_V6ONLY, 0);
+        }
+
+        if (host->socket == ENET_SOCKET_NULL || (address != NULL && enet_socket_bind(host->socket, address) < 0)) {
+            if (host->socket != ENET_SOCKET_NULL) {
+                enet_socket_destroy(host->socket);
+            }
+
+            enet_free(host->peers);
+            enet_free(host);
+
+            return NULL;
+        }
+
+        enet_socket_set_option(host->socket, ENET_SOCKOPT_NONBLOCK, 1);
+        enet_socket_set_option(host->socket, ENET_SOCKOPT_BROADCAST, 1);
+        enet_socket_set_option(host->socket, ENET_SOCKOPT_RCVBUF, ENET_HOST_RECEIVE_BUFFER_SIZE);
+        enet_socket_set_option(host->socket, ENET_SOCKOPT_SNDBUF, ENET_HOST_SEND_BUFFER_SIZE);
+        enet_socket_set_option(host->socket, ENET_SOCKOPT_IPV6_V6ONLY, 0);
+
+        if (address != NULL && enet_socket_get_address(host->socket, &host->address) < 0) {
+            host->address = *address;
+        }
+
+        if (!channelLimit || channelLimit > ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT) {
+            channelLimit = ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT;
+        } else if (channelLimit < ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT) {
+            channelLimit = ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT;
+        }
+
+        host->randomSeed                    = (enet_uint32) (size_t) host;
+        host->randomSeed                    += enet_host_random_seed();
+        host->randomSeed                    = (host->randomSeed << 16) | (host->randomSeed >> 16);
+        host->channelLimit                  = channelLimit;
+        host->incomingBandwidth             = incomingBandwidth;
+        host->outgoingBandwidth             = outgoingBandwidth;
+        host->bandwidthThrottleEpoch        = 0;
+        host->recalculateBandwidthLimits    = 0;
+        host->mtu                           = ENET_HOST_DEFAULT_MTU;
+        host->peerCount                     = peerCount;
+        host->commandCount                  = 0;
+        host->bufferCount                   = 0;
+        host->checksum                      = NULL;
+        host->receivedAddress.host          = ENET_HOST_ANY;
+        host->receivedAddress.port          = 0;
+        host->receivedData                  = NULL;
+        host->receivedDataLength            = 0;
+        host->totalSentData                 = 0;
+        host->totalSentPackets              = 0;
+        host->totalReceivedData             = 0;
+        host->totalReceivedPackets          = 0;
+        host->connectedPeers                = 0;
+        host->bandwidthLimitedPeers         = 0;
+        host->duplicatePeers                = ENET_PROTOCOL_MAXIMUM_PEER_ID;
+        host->maximumPacketSize             = ENET_HOST_DEFAULT_MAXIMUM_PACKET_SIZE;
+        host->maximumWaitingData            = ENET_HOST_DEFAULT_MAXIMUM_WAITING_DATA;
+        host->interceptCallback             = NULL;
+
+        enet_list_clear(&host->dispatchQueue);
+
+        for (currentPeer = host->peers; currentPeer < &host->peers[host->peerCount]; ++currentPeer) {
+            currentPeer->host = host;
+            currentPeer->incomingPeerID    = currentPeer - host->peers;
+            currentPeer->outgoingSessionID = currentPeer->incomingSessionID = 0xFF;
+            currentPeer->data = NULL;
+
+            enet_list_clear(&currentPeer->acknowledgements);
+            enet_list_clear(&currentPeer->sentReliableCommands);
+            enet_list_clear(&currentPeer->sentUnreliableCommands);
+            enet_list_clear(&currentPeer->outgoingReliableCommands);
+            enet_list_clear(&currentPeer->outgoingUnreliableCommands);
+            enet_list_clear(&currentPeer->dispatchedCommands);
+
+            enet_peer_reset(currentPeer);
+        }
+
+        return host;
+    }
+
+    void enet_host_destroy(ENetHost *host) {
+        ENetPeer *currentPeer;
+
+        if (host == NULL) {
+            return;
+        }
+
+        enet_socket_destroy(host->socket);
+
+        for (currentPeer = host->peers; currentPeer < &host->peers[host->peerCount]; ++currentPeer) {
+            enet_peer_reset(currentPeer);
+        }
+
+        enet_free(host->peers);
+        enet_free(host);
+    }
+
+    ENetPeer * enet_host_connect(ENetHost *host, const ENetAddress *address, size_t channelCount, enet_uint32 data) {
+        ENetPeer *currentPeer;
+        ENetChannel *channel;
+        ENetProtocol command;
+
+        if (channelCount < ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT) {
+            channelCount = ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT;
+        } else if (channelCount > ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT) {
+            channelCount = ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT;
+        }
+
+        for (currentPeer = host->peers; currentPeer < &host->peers[host->peerCount]; ++currentPeer) {
+            if (currentPeer->state == ENET_PEER_STATE_DISCONNECTED) {
+                break;
+            }
+        }
+
+        if (currentPeer >= &host->peers[host->peerCount]) {
+            return NULL;
+        }
+
+        currentPeer->channels = (ENetChannel *)enet_malloc(channelCount * sizeof(ENetChannel));
+
+        if (currentPeer->channels == NULL) {
+            return NULL;
+        }
+
+        currentPeer->channelCount = channelCount;
+        currentPeer->state        = ENET_PEER_STATE_CONNECTING;
+        currentPeer->address      = *address;
+        currentPeer->connectID    = ++host->randomSeed;
+
+        if (host->outgoingBandwidth == 0) {
+            currentPeer->windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
+        } else {
+            currentPeer->windowSize = (host->outgoingBandwidth / ENET_PEER_WINDOW_SIZE_SCALE) * ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
+        }
+
+        if (currentPeer->windowSize < ENET_PROTOCOL_MINIMUM_WINDOW_SIZE) {
+            currentPeer->windowSize = ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
+        } else if (currentPeer->windowSize > ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE) {
+            currentPeer->windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
+        }
+
+        for (channel = currentPeer->channels; channel < &currentPeer->channels[channelCount]; ++channel) {
+            channel->outgoingReliableSequenceNumber   = 0;
+            channel->outgoingUnreliableSequenceNumber = 0;
+            channel->incomingReliableSequenceNumber   = 0;
+            channel->incomingUnreliableSequenceNumber = 0;
+
+            enet_list_clear(&channel->incomingReliableCommands);
+            enet_list_clear(&channel->incomingUnreliableCommands);
+
+            channel->usedReliableWindows = 0;
+            memset(channel->reliableWindows, 0, sizeof(channel->reliableWindows));
+        }
+
+        command.header.command                     = ENET_PROTOCOL_COMMAND_CONNECT | ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE;
+        command.header.channelID                   = 0xFF;
+        command.connect.outgoingPeerID             = ENET_HOST_TO_NET_16(currentPeer->incomingPeerID);
+        command.connect.incomingSessionID          = currentPeer->incomingSessionID;
+        command.connect.outgoingSessionID          = currentPeer->outgoingSessionID;
+        command.connect.mtu                        = ENET_HOST_TO_NET_32(currentPeer->mtu);
+        command.connect.windowSize                 = ENET_HOST_TO_NET_32(currentPeer->windowSize);
+        command.connect.channelCount               = ENET_HOST_TO_NET_32(channelCount);
+        command.connect.incomingBandwidth          = ENET_HOST_TO_NET_32(host->incomingBandwidth);
+        command.connect.outgoingBandwidth          = ENET_HOST_TO_NET_32(host->outgoingBandwidth);
+        command.connect.packetThrottleInterval     = ENET_HOST_TO_NET_32(currentPeer->packetThrottleInterval);
+        command.connect.packetThrottleAcceleration = ENET_HOST_TO_NET_32(currentPeer->packetThrottleAcceleration);
+        command.connect.packetThrottleDeceleration = ENET_HOST_TO_NET_32(currentPeer->packetThrottleDeceleration);
+        command.connect.connectID                  = currentPeer->connectID;
+        command.connect.data                       = ENET_HOST_TO_NET_32(data);
+
+        enet_peer_queue_outgoing_command(currentPeer, &command, NULL, 0, 0);
+
+        return currentPeer;
+    }
+
+    void enet_host_broadcast(ENetHost *host, enet_uint8 channelID, ENetPacket *packet) {
+        ENetPeer *currentPeer;
+
+        for (currentPeer = host->peers; currentPeer < &host->peers[host->peerCount]; ++currentPeer) {
+            if (currentPeer->state != ENET_PEER_STATE_CONNECTED) {
+                continue;
+            }
+
+            enet_peer_send(currentPeer, channelID, packet);
+        }
+
+        if (packet->referenceCount == 0) {
+            enet_packet_destroy(packet);
+        }
+    }
+
+    void enet_host_channel_limit(ENetHost *host, size_t channelLimit) {
+        if (!channelLimit || channelLimit > ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT) {
+            channelLimit = ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT;
+        } else if (channelLimit < ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT) {
+            channelLimit = ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT;
+        }
+
+        host->channelLimit = channelLimit;
+    }
+
+    void enet_host_bandwidth_limit(ENetHost *host, enet_uint32 incomingBandwidth, enet_uint32 outgoingBandwidth) {
+        host->incomingBandwidth = incomingBandwidth;
+        host->outgoingBandwidth = outgoingBandwidth;
+        host->recalculateBandwidthLimits = 1;
+    }
+
+    void enet_host_bandwidth_throttle(ENetHost *host) {
+        enet_uint32 timeCurrent       = enet_time_get();
+        enet_uint32 elapsedTime       = timeCurrent - host->bandwidthThrottleEpoch;
+        enet_uint32 peersRemaining    = (enet_uint32) host->connectedPeers;
+        enet_uint32 dataTotal         = ~0;
+        enet_uint32 bandwidth         = ~0;
+        enet_uint32 throttle          = 0;
+        enet_uint32 bandwidthLimit    = 0;
+
+        int needsAdjustment = host->bandwidthLimitedPeers > 0 ? 1 : 0;
+        ENetPeer *peer;
+        ENetProtocol command;
+
+        if (elapsedTime < ENET_HOST_BANDWIDTH_THROTTLE_INTERVAL) {
+            return;
+        }
+
+        if (host->outgoingBandwidth == 0 && host->incomingBandwidth == 0) {
+            return;
+        }
+
+        host->bandwidthThrottleEpoch = timeCurrent;
+
+        if (peersRemaining == 0) {
+            return;
+        }
+
+        if (host->outgoingBandwidth != 0) {
+            dataTotal = 0;
+            bandwidth = (host->outgoingBandwidth * elapsedTime) / 1000;
+
+            for (peer = host->peers; peer < &host->peers[host->peerCount]; ++peer) {
+                if (peer->state != ENET_PEER_STATE_CONNECTED && peer->state != ENET_PEER_STATE_DISCONNECT_LATER) {
+                    continue;
+                }
+
+                dataTotal += peer->outgoingDataTotal;
+            }
+        }
+
+        while (peersRemaining > 0 && needsAdjustment != 0) {
+            needsAdjustment = 0;
+
+            if (dataTotal <= bandwidth) {
+                throttle = ENET_PEER_PACKET_THROTTLE_SCALE;
+            } else {
+                throttle = (bandwidth * ENET_PEER_PACKET_THROTTLE_SCALE) / dataTotal;
+            }
+
+            for (peer = host->peers; peer < &host->peers[host->peerCount]; ++peer) {
+                enet_uint32 peerBandwidth;
+
+                if ((peer->state != ENET_PEER_STATE_CONNECTED && peer->state != ENET_PEER_STATE_DISCONNECT_LATER) ||
+                    peer->incomingBandwidth == 0 ||
+                    peer->outgoingBandwidthThrottleEpoch == timeCurrent
+                ) {
+                    continue;
+                }
+
+                peerBandwidth = (peer->incomingBandwidth * elapsedTime) / 1000;
+
+                if ((throttle * peer->outgoingDataTotal) / ENET_PEER_PACKET_THROTTLE_SCALE <= peerBandwidth) {
+                    continue;
+                }
+
+                peer->packetThrottleLimit = (peerBandwidth * ENET_PEER_PACKET_THROTTLE_SCALE) / peer->outgoingDataTotal;
+
+                if (peer->packetThrottleLimit == 0) {
+                    peer->packetThrottleLimit = 1;
+                }
+
+                if (peer->packetThrottle > peer->packetThrottleLimit) {
+                    peer->packetThrottle = peer->packetThrottleLimit;
+                }
+
+                peer->outgoingBandwidthThrottleEpoch = timeCurrent;
+
+                peer->incomingDataTotal = 0;
+                peer->outgoingDataTotal = 0;
+
+                needsAdjustment = 1;
+                --peersRemaining;
+                bandwidth -= peerBandwidth;
+                dataTotal -= peerBandwidth;
+            }
+        }
+
+        if (peersRemaining > 0) {
+            if (dataTotal <= bandwidth) {
+                throttle = ENET_PEER_PACKET_THROTTLE_SCALE;
+            } else {
+                throttle = (bandwidth * ENET_PEER_PACKET_THROTTLE_SCALE) / dataTotal;
+            }
+
+            for (peer = host->peers;
+              peer < &host->peers[host->peerCount];
+              ++peer)
+            {
+                if ((peer->state != ENET_PEER_STATE_CONNECTED && peer->state != ENET_PEER_STATE_DISCONNECT_LATER) || peer->outgoingBandwidthThrottleEpoch == timeCurrent) {
+                    continue;
+                }
+
+                peer->packetThrottleLimit = throttle;
+
+                if (peer->packetThrottle > peer->packetThrottleLimit) {
+                    peer->packetThrottle = peer->packetThrottleLimit;
+                }
+
+                peer->incomingDataTotal = 0;
+                peer->outgoingDataTotal = 0;
+            }
+        }
+
+        if (host->recalculateBandwidthLimits) {
+            host->recalculateBandwidthLimits = 0;
+
+            peersRemaining  = (enet_uint32) host->connectedPeers;
+            bandwidth       = host->incomingBandwidth;
+            needsAdjustment = 1;
+
+            if (bandwidth == 0) {
+                bandwidthLimit = 0;
+            } else {
+                while (peersRemaining > 0 && needsAdjustment != 0) {
+                    needsAdjustment = 0;
+                    bandwidthLimit  = bandwidth / peersRemaining;
+
+                    for (peer = host->peers; peer < &host->peers[host->peerCount]; ++peer) {
+                        if ((peer->state != ENET_PEER_STATE_CONNECTED && peer->state != ENET_PEER_STATE_DISCONNECT_LATER) ||
+                            peer->incomingBandwidthThrottleEpoch == timeCurrent
+                        ) {
+                            continue;
+                        }
+
+                        if (peer->outgoingBandwidth > 0 && peer->outgoingBandwidth >= bandwidthLimit) {
+                            continue;
+                        }
+
+                        peer->incomingBandwidthThrottleEpoch = timeCurrent;
+
+                        needsAdjustment = 1;
+                        --peersRemaining;
+                        bandwidth -= peer->outgoingBandwidth;
+                    }
+                }
+            }
+
+            for (peer = host->peers; peer < &host->peers[host->peerCount]; ++peer) {
+                if (peer->state != ENET_PEER_STATE_CONNECTED && peer->state != ENET_PEER_STATE_DISCONNECT_LATER) {
+                    continue;
+                }
+
+                command.header.command   = ENET_PROTOCOL_COMMAND_BANDWIDTH_LIMIT | ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE;
+                command.header.channelID = 0xFF;
+                command.bandwidthLimit.outgoingBandwidth = ENET_HOST_TO_NET_32(host->outgoingBandwidth);
+
+                if (peer->incomingBandwidthThrottleEpoch == timeCurrent) {
+                    command.bandwidthLimit.incomingBandwidth = ENET_HOST_TO_NET_32(peer->outgoingBandwidth);
+                } else {
+                    command.bandwidthLimit.incomingBandwidth = ENET_HOST_TO_NET_32(bandwidthLimit);
+                }
+
+                enet_peer_queue_outgoing_command(peer, &command, NULL, 0, 0);
+            }
+        }
+    }
+
+// =======================================================================//
+// !
+// ! Time
+// !
+// =======================================================================//
+
+    #ifdef _WIN32
+        static LARGE_INTEGER getFILETIMEoffset() {
+            SYSTEMTIME s;
+            FILETIME f;
+            LARGE_INTEGER t;
+
+            s.wYear = 1970;
+            s.wMonth = 1;
+            s.wDay = 1;
+            s.wHour = 0;
+            s.wMinute = 0;
+            s.wSecond = 0;
+            s.wMilliseconds = 0;
+            SystemTimeToFileTime(&s, &f);
+            t.QuadPart = f.dwHighDateTime;
+            t.QuadPart <<= 32;
+            t.QuadPart |= f.dwLowDateTime;
+            return (t);
+        }
+
+        int clock_gettime(int X, struct timespec *tv) {
+            LARGE_INTEGER t;
+            FILETIME f;
+            double microseconds;
+            static LARGE_INTEGER offset;
+            static double frequencyToMicroseconds;
+            static int initialized = 0;
+            static BOOL usePerformanceCounter = 0;
+
+            if (!initialized) {
+                LARGE_INTEGER performanceFrequency;
+                initialized = 1;
+                usePerformanceCounter = QueryPerformanceFrequency(&performanceFrequency);
+                if (usePerformanceCounter) {
+                    QueryPerformanceCounter(&offset);
+                    frequencyToMicroseconds = (double)performanceFrequency.QuadPart / 1000000.;
+                } else {
+                    offset = getFILETIMEoffset();
+                    frequencyToMicroseconds = 10.;
+                }
+            }
+
+            if (usePerformanceCounter) {
+                QueryPerformanceCounter(&t);
+            } else {
+                GetSystemTimeAsFileTime(&f);
+                t.QuadPart = f.dwHighDateTime;
+                t.QuadPart <<= 32;
+                t.QuadPart |= f.dwLowDateTime;
+            }
+
+            t.QuadPart -= offset.QuadPart;
+            microseconds = (double)t.QuadPart / frequencyToMicroseconds;
+            t.QuadPart = (LONGLONG)microseconds;
+            tv->tv_sec = (long) (t.QuadPart / 1000000);
+            tv->tv_nsec = t.QuadPart % 1000000 * 1000;
+
+            return (0);
+        }
+    #elif __APPLE__ && __MAC_OS_X_VERSION_MIN_REQUIRED < 101200
+        #define CLOCK_MONOTONIC 0
+
+        int clock_gettime(int X, struct timespec *ts) {
+            clock_serv_t cclock;
+            mach_timespec_t mts;
+
+            host_get_clock_service(mach_host_self(), SYSTEM_CLOCK, &cclock);
+            clock_get_time(cclock, &mts);
+            mach_port_deallocate(mach_task_self(), cclock);
+
+            ts->tv_sec = mts.tv_sec;
+            ts->tv_nsec = mts.tv_nsec;
+
+            return 0;
+        }
+    #endif
+
+    enet_uint32 enet_time_get() {
+        static uint64_t start_time_ns = 0;
+
+        struct timespec ts;
+    #if defined(CLOCK_MONOTONIC_RAW)
+        clock_gettime(CLOCK_MONOTONIC_RAW, &ts);
+    #else
+        clock_gettime(CLOCK_MONOTONIC, &ts);
+    #endif
+
+        static const uint64_t ns_in_s = 1000 * 1000 * 1000;
+        static const uint64_t ns_in_ms = 1000 * 1000;
+
+        uint64_t current_time_ns = ts.tv_nsec + (uint64_t)ts.tv_sec * ns_in_s;
+        uint64_t offset_ns = ENET_ATOMIC_READ(&start_time_ns);
+
+        if (offset_ns == 0) {
+            uint64_t want_value = current_time_ns - 1 * ns_in_ms;
+            uint64_t old_value = ENET_ATOMIC_CAS(&start_time_ns, 0, want_value);
+
+            offset_ns = old_value == 0 ? want_value : old_value;
+        }
+
+        uint64_t result_in_ns = current_time_ns - offset_ns;
+
+        return (enet_uint32) (result_in_ns / ns_in_ms);
+    }
+
+// =======================================================================//
+// !
+// ! Extended functionality
+// !
+// =======================================================================//
+
+    void * enet_packet_get_data(ENetPacket *packet) {
+        return (void *)packet->data;
+    }
+
+    int enet_packet_get_length(ENetPacket *packet) {
+        return packet->dataLength;
+    }
+
+    void enet_packet_set_free_callback(ENetPacket *packet, const void *callback) {
+        packet->freeCallback = (ENetPacketFreeCallback)callback;
+    }
+
+    void enet_packet_dispose(ENetPacket *packet) {
+        if (packet->referenceCount == 0) {
+            enet_packet_destroy(packet);
+        }
+    }
+
+    enet_uint32 enet_host_get_peers_count(ENetHost *host) {
+        return host->connectedPeers;
+    }
+
+    enet_uint32 enet_host_get_packets_sent(ENetHost *host) {
+        return host->totalSentPackets;
+    }
+
+    enet_uint32 enet_host_get_packets_received(ENetHost *host) {
+        return host->totalReceivedPackets;
+    }
+
+    enet_uint32 enet_host_get_bytes_sent(ENetHost *host) {
+        return host->totalSentData;
+    }
+
+    enet_uint32 enet_host_get_bytes_received(ENetHost *host) {
+        return host->totalReceivedData;
+    }
+
+    enet_uint32 enet_peer_get_id(ENetPeer *peer) {
+        return peer->connectID;
+    }
+
+    int enet_peer_get_ip(ENetPeer *peer, char *ip, size_t ipLength) {
+        return enet_address_get_host_ip(&peer->address, ip, ipLength);
+    }
+
+    enet_uint16 enet_peer_get_port(ENetPeer *peer) {
+        return peer->address.port;
+    }
+
+    ENetPeerState enet_peer_get_state(ENetPeer *peer) {
+        return peer->state;
+    }
+
+    enet_uint32 enet_peer_get_rtt(ENetPeer *peer) {
+        return peer->roundTripTime;
+    }
+
+    enet_uint64 enet_peer_get_packets_sent(ENetPeer *peer) {
+        return peer->totalPacketsSent;
+    }
+
+    enet_uint32 enet_peer_get_packets_lost(ENetPeer *peer) {
+        return peer->totalPacketsLost;
+    }
+
+    enet_uint64 enet_peer_get_bytes_sent(ENetPeer *peer) {
+        return peer->totalDataSent;
+    }
+
+    enet_uint64 enet_peer_get_bytes_received(ENetPeer *peer) {
+        return peer->totalDataReceived;
+    }
+ 
+    void * enet_peer_get_data(ENetPeer *peer) {
+        return (void *)peer->data;
+    }
+
+    void enet_peer_set_data(ENetPeer *peer, const void *data) {
+        peer->data = (enet_uint32 *)data;
+    }
+
+// =======================================================================//
+// !
+// ! Platform Specific (Unix)
+// !
+// =======================================================================//
+
+    #ifndef _WIN32
+        int enet_initialize(void) {
+            return 0;
+        }
+
+        void enet_deinitialize(void);
+
+        enet_uint64 enet_host_random_seed(void) {
+            return (enet_uint64) time(NULL);
+        }
+
+        int enet_address_set_host_ip(ENetAddress *address, const char *name) {
+            if (!inet_pton(AF_INET6, name, &address->host)) {
+                return -1;
+            }
+
+            return 0;
+        }
+
+        int enet_address_set_host(ENetAddress *address, const char *name) {
+            struct addrinfo hints, *resultList = NULL, *result = NULL;
+
+            memset(&hints, 0, sizeof(hints));
+            hints.ai_family = AF_UNSPEC;
+
+            if (getaddrinfo(name, NULL, &hints, &resultList) != 0) {
+                return -1;
+            }
+
+            for (result = resultList; result != NULL; result = result->ai_next) {
+                if (result->ai_addr != NULL && result->ai_addrlen >= sizeof(struct sockaddr_in)) {
+                    if (result->ai_family == AF_INET) {
+                        struct sockaddr_in * sin = (struct sockaddr_in *)result->ai_addr;
+
+                        ((uint32_t *)&address->host.s6_addr)[0] = 0;
+                        ((uint32_t *)&address->host.s6_addr)[1] = 0;
+                        ((uint32_t *)&address->host.s6_addr)[2] = htonl(0xffff);
+                        ((uint32_t *)&address->host.s6_addr)[3] = sin->sin_addr.s_addr;
+
+                        freeaddrinfo(resultList);
+
+                        return 0;
+                    } else if (result->ai_family == AF_INET6) {
+                        struct sockaddr_in6 * sin = (struct sockaddr_in6 *)result->ai_addr;
+
+                        address->host = sin->sin6_addr;
+                        address->sin6_scope_id = sin->sin6_scope_id;
+
+                        freeaddrinfo(resultList);
+
+                        return 0;
+                    }
+                }
+            }
+
+            if (resultList != NULL) {
+                freeaddrinfo(resultList);
+            }
+
+            return enet_address_set_host_ip(address, name);
+        }
+
+        int enet_address_get_host_ip(const ENetAddress *address, char *name, size_t nameLength) {
+            if (inet_ntop(AF_INET6, &address->host, name, nameLength) == NULL) {
+                return -1;
+            }
+
+            return 0;
+        }
+
+        int enet_address_get_host(const ENetAddress *address, char *name, size_t nameLength) {
+            struct sockaddr_in6 sin;
+            int err;
+
+            memset(&sin, 0, sizeof(struct sockaddr_in6));
+
+            sin.sin6_family = AF_INET6;
+            sin.sin6_port = ENET_HOST_TO_NET_16 (address->port);
+            sin.sin6_addr = address->host;
+            sin.sin6_scope_id = address->sin6_scope_id;
+
+            err = getnameinfo((struct sockaddr *)&sin, sizeof(sin), name, nameLength, NULL, 0, NI_NAMEREQD);
+
+            if (!err) {
+                if (name != NULL && nameLength > 0 && !memchr(name, '\0', nameLength)) {
+                    return -1;
+                }
+
+                return 0;
+            }
+
+            if (err != EAI_NONAME) {
+                return -1;
+            }
+
+            return enet_address_get_host_ip(address, name, nameLength);
+        }
+
+        int enet_socket_bind(ENetSocket socket, const ENetAddress *address) {
+            struct sockaddr_in6 sin;
+            memset(&sin, 0, sizeof(struct sockaddr_in6));
+            sin.sin6_family = AF_INET6;
+
+            if (address != NULL) {
+                sin.sin6_port       = ENET_HOST_TO_NET_16(address->port);
+                sin.sin6_addr       = address->host;
+                sin.sin6_scope_id   = address->sin6_scope_id;
+            } else {
+                sin.sin6_port       = 0;
+                sin.sin6_addr       = ENET_HOST_ANY;
+                sin.sin6_scope_id   = 0;
+            }
+
+            return bind(socket, (struct sockaddr *)&sin, sizeof(struct sockaddr_in6));
+        }
+
+        int enet_socket_get_address(ENetSocket socket, ENetAddress *address) {
+            struct sockaddr_in6 sin;
+            socklen_t sinLength = sizeof(struct sockaddr_in6);
+
+            if (getsockname(socket, (struct sockaddr *)&sin, &sinLength) == -1) {
+                return -1;
+            }
+
+            address->host           = sin.sin6_addr;
+            address->port           = ENET_NET_TO_HOST_16(sin.sin6_port);
+            address->sin6_scope_id  = sin.sin6_scope_id;
+
+            return 0;
+        }
+
+        int enet_socket_listen(ENetSocket socket, int backlog) {
+            return listen(socket, backlog < 0 ? SOMAXCONN : backlog);
+        }
+
+        ENetSocket enet_socket_create(ENetSocketType type) {
+            return socket(PF_INET6, type == ENET_SOCKET_TYPE_DATAGRAM ? SOCK_DGRAM : SOCK_STREAM, 0);
+        }
+
+        int enet_socket_set_option(ENetSocket socket, ENetSocketOption option, int value) {
+            int result = -1;
+
+            switch (option) {
+                case ENET_SOCKOPT_NONBLOCK:
+                    result = fcntl(socket, F_SETFL, (value ? O_NONBLOCK : 0) | (fcntl(socket, F_GETFL) & ~O_NONBLOCK));
+                    break;
+
+                case ENET_SOCKOPT_BROADCAST:
+                    result = setsockopt(socket, SOL_SOCKET, SO_BROADCAST, (char *)&value, sizeof(int));
+                    break;
+
+                case ENET_SOCKOPT_REUSEADDR:
+                    result = setsockopt(socket, SOL_SOCKET, SO_REUSEADDR, (char *)&value, sizeof(int));
+                    break;
+
+                case ENET_SOCKOPT_RCVBUF:
+                    result = setsockopt(socket, SOL_SOCKET, SO_RCVBUF, (char *)&value, sizeof(int));
+                    break;
+
+                case ENET_SOCKOPT_SNDBUF:
+                    result = setsockopt(socket, SOL_SOCKET, SO_SNDBUF, (char *)&value, sizeof(int));
+                    break;
+
+                case ENET_SOCKOPT_RCVTIMEO: {
+                    struct timeval timeVal;
+                    timeVal.tv_sec  = value / 1000;
+                    timeVal.tv_usec = (value % 1000) * 1000;
+                    result = setsockopt(socket, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeVal, sizeof(struct timeval));
+                    break;
+                }
+
+                case ENET_SOCKOPT_SNDTIMEO: {
+                    struct timeval timeVal;
+                    timeVal.tv_sec  = value / 1000;
+                    timeVal.tv_usec = (value % 1000) * 1000;
+                    result = setsockopt(socket, SOL_SOCKET, SO_SNDTIMEO, (char *)&timeVal, sizeof(struct timeval));
+                    break;
+                }
+
+                case ENET_SOCKOPT_NODELAY:
+                    result = setsockopt(socket, IPPROTO_TCP, TCP_NODELAY, (char *)&value, sizeof(int));
+                    break;
+
+                case ENET_SOCKOPT_IPV6_V6ONLY:
+                    result = setsockopt(socket, IPPROTO_IPV6, IPV6_V6ONLY, (char *)&value, sizeof(int));
+                    break;
+
+                default:
+                    break;
+            }
+
+            return result == -1 ? -1 : 0;
+        }
+
+        int enet_socket_get_option(ENetSocket socket, ENetSocketOption option, int *value) {
+            int result = -1;
+            socklen_t len;
+
+            switch (option) {
+                case ENET_SOCKOPT_ERROR:
+                    len    = sizeof(int);
+                    result = getsockopt(socket, SOL_SOCKET, SO_ERROR, value, &len);
+                    break;
+
+                default:
+                    break;
+            }
+
+            return result == -1 ? -1 : 0;
+        }
+
+        int enet_socket_connect(ENetSocket socket, const ENetAddress *address) {
+            struct sockaddr_in6 sin;
+            int result;
+
+            memset(&sin, 0, sizeof(struct sockaddr_in6));
+
+            sin.sin6_family     = AF_INET6;
+            sin.sin6_port       = ENET_HOST_TO_NET_16(address->port);
+            sin.sin6_addr       = address->host;
+            sin.sin6_scope_id   = address->sin6_scope_id;
+
+            result = connect(socket, (struct sockaddr *)&sin, sizeof(struct sockaddr_in6));
+
+            if (result == -1 && errno == EINPROGRESS) {
+                return 0;
+            }
+
+            return result;
+        }
+
+        ENetSocket enet_socket_accept(ENetSocket socket, ENetAddress *address) {
+            int result;
+            struct sockaddr_in6 sin;
+            socklen_t sinLength = sizeof(struct sockaddr_in6);
+
+            result = accept(socket,address != NULL ? (struct sockaddr *)&sin : NULL, address != NULL ? &sinLength : NULL);
+
+            if (result == -1) {
+                return ENET_SOCKET_NULL;
+            }
+
+            if (address != NULL) {
+                address->host = sin.sin6_addr;
+                address->port = ENET_NET_TO_HOST_16 (sin.sin6_port);
+                address->sin6_scope_id = sin.sin6_scope_id;
+            }
+
+            return result;
+        }
+
+        int enet_socket_shutdown(ENetSocket socket, ENetSocketShutdown how) {
+            return shutdown(socket, (int)how);
+        }
+
+        void enet_socket_destroy(ENetSocket socket) {
+            if (socket != -1) {
+                close(socket);
+            }
+        }
+
+        int enet_socket_send(ENetSocket socket, const ENetAddress *address, const ENetBuffer *buffers, size_t bufferCount) {
+            struct msghdr msgHdr;
+            struct sockaddr_in6 sin;
+            int sentLength;
+
+            memset(&msgHdr, 0, sizeof(struct msghdr));
+
+            if (address != NULL) {
+                memset(&sin, 0, sizeof(struct sockaddr_in6));
+
+                sin.sin6_family     = AF_INET6;
+                sin.sin6_port       = ENET_HOST_TO_NET_16(address->port);
+                sin.sin6_addr       = address->host;
+                sin.sin6_scope_id   = address->sin6_scope_id;
+
+                msgHdr.msg_name    = &sin;
+                msgHdr.msg_namelen = sizeof(struct sockaddr_in6);
+            }
+
+            msgHdr.msg_iov    = (struct iovec *)buffers;
+            msgHdr.msg_iovlen = bufferCount;
+
+            sentLength = sendmsg(socket, &msgHdr, MSG_NOSIGNAL);
+
+            if (sentLength == -1) {
+                if (errno == EWOULDBLOCK) {
+                    return 0;
+                }
+
+                return -1;
+            }
+
+            return sentLength;
+        }
+
+        int enet_socket_receive(ENetSocket socket, ENetAddress *address, ENetBuffer *buffers, size_t bufferCount) {
+            struct msghdr msgHdr;
+            struct sockaddr_in6 sin;
+            int recvLength;
+
+            memset(&msgHdr, 0, sizeof(struct msghdr));
+
+            if (address != NULL) {
+                msgHdr.msg_name    = &sin;
+                msgHdr.msg_namelen = sizeof(struct sockaddr_in6);
+            }
+
+            msgHdr.msg_iov    = (struct iovec *)buffers;
+            msgHdr.msg_iovlen = bufferCount;
+
+            recvLength = recvmsg(socket, &msgHdr, MSG_NOSIGNAL);
+
+            if (recvLength == -1) {
+                if (errno == EWOULDBLOCK) {
+                    return 0;
+                }
+
+                return -1;
+            }
+
+            if (msgHdr.msg_flags & MSG_TRUNC) {
+                return -1;
+            }
+
+            if (address != NULL) {
+                address->host           = sin.sin6_addr;
+                address->port           = ENET_NET_TO_HOST_16(sin.sin6_port);
+                address->sin6_scope_id  = sin.sin6_scope_id;
+            }
+
+            return recvLength;
+        }
+
+        int enet_socketset_select(ENetSocket maxSocket, ENetSocketSet *readSet, ENetSocketSet *writeSet, enet_uint32 timeout) {
+            struct timeval timeVal;
+
+            timeVal.tv_sec  = timeout / 1000;
+            timeVal.tv_usec = (timeout % 1000) * 1000;
+
+            return select(maxSocket + 1, readSet, writeSet, NULL, &timeVal);
+        }
+
+        int enet_socket_wait(ENetSocket socket, enet_uint32 *condition, enet_uint64 timeout) {
+            struct pollfd pollSocket;
+            int pollCount;
+
+            pollSocket.fd     = socket;
+            pollSocket.events = 0;
+
+            if (*condition & ENET_SOCKET_WAIT_SEND) {
+                pollSocket.events |= POLLOUT;
+            }
+
+            if (*condition & ENET_SOCKET_WAIT_RECEIVE) {
+                pollSocket.events |= POLLIN;
+            }
+
+            pollCount = poll(&pollSocket, 1, timeout);
+
+            if (pollCount < 0) {
+                if (errno == EINTR && *condition & ENET_SOCKET_WAIT_INTERRUPT) {
+                    *condition = ENET_SOCKET_WAIT_INTERRUPT;
+
+                    return 0;
+                }
+
+                return -1;
+            }
+
+            *condition = ENET_SOCKET_WAIT_NONE;
+
+            if (pollCount == 0) {
+                return 0;
+            }
+
+            if (pollSocket.revents & POLLOUT) {
+                *condition |= ENET_SOCKET_WAIT_SEND;
+            }
+
+            if (pollSocket.revents & POLLIN) {
+                *condition |= ENET_SOCKET_WAIT_RECEIVE;
+            }
+
+            return 0;
+        }
+    #endif
+
+// =======================================================================//
+// !
+// ! Platform Specific (Win)
+// !
+// =======================================================================//
+
+    #ifdef _WIN32
+        #ifdef __MINGW32__
+            const char *inet_ntop(int af, const void *src, char *dst, socklen_t cnt) {
+                if (af == AF_INET) {
+                    struct sockaddr_in in;
+                    memset(&in, 0, sizeof(in));
+                    in.sin_family = AF_INET;
+                    memcpy(&in.sin_addr, src, sizeof(struct in_addr));
+                    getnameinfo((struct sockaddr *)&in, sizeof(struct sockaddr_in), dst, cnt, NULL, 0, NI_NUMERICHOST);
+                    return dst;
+                } else if (af == AF_INET6) {
+                    struct sockaddr_in6 in;
+                    memset(&in, 0, sizeof(in));
+                    in.sin6_family = AF_INET6;
+                    memcpy(&in.sin6_addr, src, sizeof(struct in_addr6));
+                    getnameinfo((struct sockaddr *)&in, sizeof(struct sockaddr_in6), dst, cnt, NULL, 0, NI_NUMERICHOST);
+                    return dst;
+                }
+
+                return NULL;
+            }
+
+            #define NS_INADDRSZ  4
+            #define NS_IN6ADDRSZ 16
+            #define NS_INT16SZ   2
+
+            int inet_pton4(const char *src, char *dst) {
+                uint8_t tmp[NS_INADDRSZ], *tp;
+
+                int saw_digit = 0;
+                int octets = 0;
+                *(tp = tmp) = 0;
+
+                int ch;
+
+                while ((ch = *src++) != '\0') {
+                    if (ch >= '0' && ch <= '9') {
+                        uint32_t n = *tp * 10 + (ch - '0');
+
+                        if (saw_digit && *tp == 0)
+                            return 0;
+
+                        if (n > 255)
+                            return 0;
+
+                        *tp = n;
+
+                        if (!saw_digit) {
+                            if (++octets > 4)
+                                return 0;
+
+                            saw_digit = 1;
+                        }
+                    } else if (ch == '.' && saw_digit) {
+                        if (octets == 4)
+                            return 0;
+
+                        *++tp = 0;
+                        saw_digit = 0;
+                    } else
+                        return 0;
+                }
+                if (octets < 4)
+                    return 0;
+
+                memcpy(dst, tmp, NS_INADDRSZ);
+
+                return 1;
+            }
+
+            int inet_pton6(const char *src, char *dst) {
+                static const char xdigits[] = "0123456789abcdef";
+                uint8_t tmp[NS_IN6ADDRSZ];
+
+                uint8_t *tp = (uint8_t*)memset(tmp, '\0', NS_IN6ADDRSZ);
+                uint8_t *endp = tp + NS_IN6ADDRSZ;
+                uint8_t *colonp = NULL;
+
+                /* Leading :: requires some special handling. */
+                if (*src == ':') {
+                    if (*++src != ':')
+                        return 0;
+                }
+
+                const char *curtok = src;
+                int saw_xdigit = 0;
+                uint32_t val = 0;
+                int ch;
+                while ((ch = tolower(*src++)) != '\0') {
+                    const char *pch = strchr(xdigits, ch);
+
+                    if (pch != NULL) {
+                        val <<= 4;
+                        val |= (pch - xdigits);
+
+                        if (val > 0xffff)
+                            return 0;
+
+                        saw_xdigit = 1;
+
+                        continue;
+                    }
+
+                    if (ch == ':') {
+                        curtok = src;
+                        if (!saw_xdigit) {
+                            if (colonp)
+                                return 0;
+
+                            colonp = tp;
+
+                            continue;
+                        } else if (*src == '\0') {
+                            return 0;
+                        }
+
+                        if (tp + NS_INT16SZ > endp)
+                            return 0;
+
+                        *tp++ = (uint8_t) (val >> 8) & 0xff;
+                        *tp++ = (uint8_t) val & 0xff;
+                        saw_xdigit = 0;
+                        val = 0;
+
+                        continue;
+                    }
+
+                    if (ch == '.' && ((tp + NS_INADDRSZ) <= endp) && inet_pton4(curtok, (char*)tp) > 0) {
+                        tp += NS_INADDRSZ;
+                        saw_xdigit = 0;
+                        break; /* '\0' was seen by inet_pton4(). */
+                    }
+
+                    return 0;
+                }
+
+                if (saw_xdigit) {
+                    if (tp + NS_INT16SZ > endp)
+                        return 0;
+
+                    *tp++ = (uint8_t) (val >> 8) & 0xff;
+                    *tp++ = (uint8_t) val & 0xff;
+                }
+
+                if (colonp != NULL) {
+                    /*
+                     * Since some memmove()'s erroneously fail to handle
+                     * overlapping regions, we'll do the shift by hand.
+                     */
+                    const int n = tp - colonp;
+
+                    if (tp == endp)
+                        return 0;
+
+                    for (int i = 1; i <= n; i++) {
+                        endp[-i] = colonp[n - i];
+                        colonp[n - i] = 0;
+                    }
+
+                    tp = endp;
+                }
+
+                if (tp != endp)
+                    return 0;
+
+                memcpy(dst, tmp, NS_IN6ADDRSZ);
+
+                return 1;
+            }
+
+            int inet_pton(int af, const char *src, struct in6_addr *dst) {
+                switch (af) {
+                    case AF_INET:
+                        return inet_pton4(src, (char *)dst);
+
+                    case AF_INET6:
+                        return inet_pton6(src, (char *)dst);
+
+                    default:
+                        return -1;
+                }
+            }
+        #endif
+
+        int enet_initialize(void) {
+            WORD versionRequested = MAKEWORD(1, 1);
+            WSADATA wsaData;
+
+            if (WSAStartup(versionRequested, &wsaData)) {
+                return -1;
+            }
+
+            if (LOBYTE(wsaData.wVersion) != 1 || HIBYTE(wsaData.wVersion) != 1) {
+                WSACleanup();
+                return -1;
+            }
+
+            timeBeginPeriod(1);
+            return 0;
+        }
+
+        void enet_deinitialize(void) {
+            timeEndPeriod(1);
+            WSACleanup();
+        }
+
+        enet_uint64 enet_host_random_seed(void) {
+            return (enet_uint64) timeGetTime();
+        }
+
+        int enet_address_set_host_ip(ENetAddress *address, const char *name) {
+            enet_uint8 vals[4] = { 0, 0, 0, 0 };
+            int i;
+
+            for (i = 0; i < 4; ++i) {
+                const char *next = name + 1;
+                if (*name != '0') {
+                    long val = strtol(name, (char **)&next, 10);
+
+                    if (val < 0 || val > 255 || next == name || next - name > 3) {
+                        return -1;
+                    }
+
+                    vals[i] = (enet_uint8) val;
+                }
+
+                if (*next != (i < 3 ? '.' : '\0')) {
+                    return -1;
+                }
+
+                name = next + 1;
+            }
+
+            memcpy(&address->host, vals, sizeof(enet_uint32));
+
+            return 0;
+        }
+
+        int enet_address_set_host(ENetAddress *address, const char *name) {
+            struct hostent *hostEntry = NULL;
+            hostEntry = gethostbyname(name);
+
+            if (hostEntry == NULL || hostEntry->h_addrtype != AF_INET) {
+                if (!inet_pton(AF_INET6, name, &address->host)) {
+                    return -1;
+                }
+
+                return 0;
+            }
+
+            ((enet_uint32 *)&address->host.s6_addr)[0] = 0;
+            ((enet_uint32 *)&address->host.s6_addr)[1] = 0;
+            ((enet_uint32 *)&address->host.s6_addr)[2] = htonl(0xffff);
+            ((enet_uint32 *)&address->host.s6_addr)[3] = *(enet_uint32 *)hostEntry->h_addr_list[0];
+
+            return 0;
+        }
+
+        int enet_address_get_host_ip(const ENetAddress *address, char *name, size_t nameLength) {
+            if (inet_ntop(AF_INET6, (PVOID)&address->host, name, nameLength) == NULL) {
+                return -1;
+            }
+
+            return 0;
+        }
+
+        int enet_address_get_host(const ENetAddress *address, char *name, size_t nameLength) {
+            struct in6_addr in;
+            struct hostent *hostEntry = NULL;
+
+            in = address->host;
+            hostEntry = gethostbyaddr((char *)&in, sizeof(struct in6_addr), AF_INET6);
+
+            if (hostEntry == NULL) {
+                return enet_address_get_host_ip(address, name, nameLength);
+            } else {
+                size_t hostLen = strlen(hostEntry->h_name);
+                if (hostLen >= nameLength) {
+                    return -1;
+                }
+                memcpy(name, hostEntry->h_name, hostLen + 1);
+            }
+
+            return 0;
+        }
+
+        int enet_socket_bind(ENetSocket socket, const ENetAddress *address) {
+            struct sockaddr_in6 sin;
+            memset(&sin, 0, sizeof(struct sockaddr_in6));
+            sin.sin6_family = AF_INET6;
+
+            if (address != NULL) {
+                sin.sin6_port       = ENET_HOST_TO_NET_16 (address->port);
+                sin.sin6_addr       = address->host;
+                sin.sin6_scope_id   = address->sin6_scope_id;
+            } else {
+                sin.sin6_port       = 0;
+                sin.sin6_addr       = in6addr_any;
+                sin.sin6_scope_id   = 0;
+            }
+
+            return bind(socket, (struct sockaddr *)&sin, sizeof(struct sockaddr_in6)) == SOCKET_ERROR ? -1 : 0;
+        }
+
+        int enet_socket_get_address(ENetSocket socket, ENetAddress *address) {
+            struct sockaddr_in6 sin;
+            int sinLength = sizeof(struct sockaddr_in6);
+
+            if (getsockname(socket, (struct sockaddr *)&sin, &sinLength) == -1) {
+                return -1;
+            }
+
+            address->host           = sin.sin6_addr;
+            address->port           = ENET_NET_TO_HOST_16(sin.sin6_port);
+            address->sin6_scope_id  = sin.sin6_scope_id;
+
+            return 0;
+        }
+
+        int enet_socket_listen(ENetSocket socket, int backlog) {
+            return listen(socket, backlog < 0 ? SOMAXCONN : backlog) == SOCKET_ERROR ? -1 : 0;
+        }
+
+        ENetSocket enet_socket_create(ENetSocketType type) {
+            return socket(PF_INET6, type == ENET_SOCKET_TYPE_DATAGRAM ? SOCK_DGRAM : SOCK_STREAM, 0);
+        }
+
+        int enet_socket_set_option(ENetSocket socket, ENetSocketOption option, int value) {
+            int result = SOCKET_ERROR;
+
+            switch (option) {
+                case ENET_SOCKOPT_NONBLOCK: {
+                    u_long nonBlocking = (u_long) value;
+                    result = ioctlsocket(socket, FIONBIO, &nonBlocking);
+                    break;
+                }
+
+                case ENET_SOCKOPT_BROADCAST:
+                    result = setsockopt(socket, SOL_SOCKET, SO_BROADCAST, (char *)&value, sizeof(int));
+                    break;
+
+                case ENET_SOCKOPT_REUSEADDR:
+                    result = setsockopt(socket, SOL_SOCKET, SO_REUSEADDR, (char *)&value, sizeof(int));
+                    break;
+
+                case ENET_SOCKOPT_RCVBUF:
+                    result = setsockopt(socket, SOL_SOCKET, SO_RCVBUF, (char *)&value, sizeof(int));
+                    break;
+
+                case ENET_SOCKOPT_SNDBUF:
+                    result = setsockopt(socket, SOL_SOCKET, SO_SNDBUF, (char *)&value, sizeof(int));
+                    break;
+
+                case ENET_SOCKOPT_RCVTIMEO:
+                    result = setsockopt(socket, SOL_SOCKET, SO_RCVTIMEO, (char *)&value, sizeof(int));
+                    break;
+
+                case ENET_SOCKOPT_SNDTIMEO:
+                    result = setsockopt(socket, SOL_SOCKET, SO_SNDTIMEO, (char *)&value, sizeof(int));
+                    break;
+
+                case ENET_SOCKOPT_NODELAY:
+                    result = setsockopt(socket, IPPROTO_TCP, TCP_NODELAY, (char *)&value, sizeof(int));
+                    break;
+
+                case ENET_SOCKOPT_IPV6_V6ONLY:
+                    result = setsockopt(socket, IPPROTO_IPV6, IPV6_V6ONLY, (char *)&value, sizeof(int));
+                    break;
+
+                default:
+                    break;
+            }
+            return result == SOCKET_ERROR ? -1 : 0;
+        }
+
+        int enet_socket_get_option(ENetSocket socket, ENetSocketOption option, int *value) {
+            int result = SOCKET_ERROR, len;
+
+            switch (option) {
+                case ENET_SOCKOPT_ERROR:
+                    len    = sizeof(int);
+                    result = getsockopt(socket, SOL_SOCKET, SO_ERROR, (char *)value, &len);
+                    break;
+
+                default:
+                    break;
+            }
+            return result == SOCKET_ERROR ? -1 : 0;
+        }
+
+        int enet_socket_connect(ENetSocket socket, const ENetAddress *address) {
+            struct sockaddr_in6 sin;
+            int result;
+
+            memset(&sin, 0, sizeof(struct sockaddr_in6));
+
+            sin.sin6_family     = AF_INET6;
+            sin.sin6_port       = ENET_HOST_TO_NET_16(address->port);
+            sin.sin6_addr       = address->host;
+            sin.sin6_scope_id   = address->sin6_scope_id;
+
+            result = connect(socket, (struct sockaddr *)&sin, sizeof(struct sockaddr_in6));
+
+            if (result == SOCKET_ERROR && WSAGetLastError() != WSAEWOULDBLOCK) {
+                return -1;
+            }
+
+            return 0;
+        }
+
+        ENetSocket enet_socket_accept(ENetSocket socket, ENetAddress *address) {
+            SOCKET result;
+            struct sockaddr_in6 sin;
+            int sinLength = sizeof(struct sockaddr_in6);
+
+            result = accept(socket, address != NULL ? (struct sockaddr *)&sin : NULL, address != NULL ? &sinLength : NULL);
+
+            if (result == INVALID_SOCKET) {
+                return ENET_SOCKET_NULL;
+            }
+
+            if (address != NULL) {
+                address->host           = sin.sin6_addr;
+                address->port           = ENET_NET_TO_HOST_16(sin.sin6_port);
+                address->sin6_scope_id  = sin.sin6_scope_id;
+            }
+
+            return result;
+        }
+
+        int enet_socket_shutdown(ENetSocket socket, ENetSocketShutdown how) {
+            return shutdown(socket, (int)how) == SOCKET_ERROR ? -1 : 0;
+        }
+
+        void enet_socket_destroy(ENetSocket socket) {
+            if (socket != INVALID_SOCKET) {
+                closesocket(socket);
+            }
+        }
+
+        int enet_socket_send(ENetSocket socket, const ENetAddress *address, const ENetBuffer *buffers, size_t bufferCount) {
+            struct sockaddr_in6 sin;
+            DWORD sentLength;
+
+            if (address != NULL) {
+                memset(&sin, 0, sizeof(struct sockaddr_in6));
+
+                sin.sin6_family     = AF_INET6;
+                sin.sin6_port       = ENET_HOST_TO_NET_16(address->port);
+                sin.sin6_addr       = address->host;
+                sin.sin6_scope_id   = address->sin6_scope_id;
+            }
+
+            if (WSASendTo(socket,
+                (LPWSABUF) buffers,
+                (DWORD) bufferCount,
+                &sentLength,
+                0,
+                address != NULL ? (struct sockaddr *)&sin : NULL,
+                address != NULL ? sizeof(struct sockaddr_in6) : 0,
+                NULL,
+                NULL) == SOCKET_ERROR
+            ) {
+                return (WSAGetLastError() == WSAEWOULDBLOCK) ? 0 : 1;
+            }
+
+            return (int)sentLength;
+        }
+
+        int enet_socket_receive(ENetSocket socket, ENetAddress *address, ENetBuffer *buffers, size_t bufferCount) {
+            INT sinLength = sizeof(struct sockaddr_in6);
+            DWORD flags   = 0, recvLength;
+            struct sockaddr_in6 sin;
+
+            if (WSARecvFrom(socket,
+                (LPWSABUF) buffers,
+                (DWORD) bufferCount,
+                &recvLength,
+                &flags,
+                address != NULL ? (struct sockaddr *)&sin : NULL,
+                address != NULL ? &sinLength : NULL,
+                NULL,
+                NULL) == SOCKET_ERROR
+            ) {
+                switch (WSAGetLastError()) {
+                    case WSAEWOULDBLOCK:
+                    case WSAECONNRESET:
+                        return 0;
+                }
+
+                return -1;
+            }
+
+            if (flags & MSG_PARTIAL) {
+                return -1;
+            }
+
+            if (address != NULL) {
+                address->host           = sin.sin6_addr;
+                address->port           = ENET_NET_TO_HOST_16(sin.sin6_port);
+                address->sin6_scope_id  = sin.sin6_scope_id;
+            }
+
+            return (int)recvLength;
+        }
+
+        int enet_socketset_select(ENetSocket maxSocket, ENetSocketSet *readSet, ENetSocketSet *writeSet, enet_uint32 timeout) {
+            struct timeval timeVal;
+
+            timeVal.tv_sec  = timeout / 1000;
+            timeVal.tv_usec = (timeout % 1000) * 1000;
+
+            return select(maxSocket + 1, readSet, writeSet, NULL, &timeVal);
+        }
+
+        int enet_socket_wait(ENetSocket socket, enet_uint32 *condition, enet_uint64 timeout) {
+            fd_set readSet, writeSet;
+            struct timeval timeVal;
+            int selectCount;
+
+            timeVal.tv_sec  = timeout / 1000;
+            timeVal.tv_usec = (timeout % 1000) * 1000;
+
+            FD_ZERO(&readSet);
+            FD_ZERO(&writeSet);
+
+            if (*condition & ENET_SOCKET_WAIT_SEND) {
+                FD_SET(socket, &writeSet);
+            }
+
+            if (*condition & ENET_SOCKET_WAIT_RECEIVE) {
+                FD_SET(socket, &readSet);
+            }
+
+            selectCount = select(socket + 1, &readSet, &writeSet, NULL, &timeVal);
+
+            if (selectCount < 0) {
+                return -1;
+            }
+
+            *condition = ENET_SOCKET_WAIT_NONE;
+
+            if (selectCount == 0) {
+                return 0;
+            }
+
+            if (FD_ISSET(socket, &writeSet)) {
+                *condition |= ENET_SOCKET_WAIT_SEND;
+            }
+
+            if (FD_ISSET(socket, &readSet)) {
+                *condition |= ENET_SOCKET_WAIT_RECEIVE;
+            }
+
+            return 0;
+        }
+    #endif
+
+#ifdef __cplusplus
+}
+#endif
+#endif
+#endif