// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: HekateServerProto.proto

#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
#include "HekateServerProto.pb.h"

#include <algorithm>

#include <google/protobuf/stubs/common.h>
#include <google/protobuf/stubs/once.h>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/wire_format_lite_inl.h>
#include <google/protobuf/descriptor.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/reflection_ops.h>
#include <google/protobuf/wire_format.h>
// @@protoc_insertion_point(includes)

namespace Hekate {
namespace Protobuf {
namespace Proto {
namespace Server {

namespace {

const ::google::protobuf::Descriptor* SendMessage__descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  SendMessage__reflection_ = NULL;
const ::google::protobuf::Descriptor* SendToMessage_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  SendToMessage_reflection_ = NULL;
const ::google::protobuf::Descriptor* WSASendMessage_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  WSASendMessage_reflection_ = NULL;
const ::google::protobuf::Descriptor* WSASendToMessage_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  WSASendToMessage_reflection_ = NULL;
const ::google::protobuf::Descriptor* RecvMessage_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  RecvMessage_reflection_ = NULL;
const ::google::protobuf::Descriptor* RecvFromMessage_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  RecvFromMessage_reflection_ = NULL;
const ::google::protobuf::Descriptor* WSARecvMessage_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  WSARecvMessage_reflection_ = NULL;
const ::google::protobuf::Descriptor* WSARecvFromMessage_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  WSARecvFromMessage_reflection_ = NULL;
const ::google::protobuf::Descriptor* HekateToClientMessage_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  HekateToClientMessage_reflection_ = NULL;
const ::google::protobuf::Descriptor* AcknowledgeMessage_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  AcknowledgeMessage_reflection_ = NULL;
const ::google::protobuf::Descriptor* FilterHitMessage_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  FilterHitMessage_reflection_ = NULL;
const ::google::protobuf::Descriptor* HekateMessage_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  HekateMessage_reflection_ = NULL;

}  // namespace


void protobuf_AssignDesc_HekateServerProto_2eproto() {
  protobuf_AddDesc_HekateServerProto_2eproto();
  const ::google::protobuf::FileDescriptor* file =
    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
      "HekateServerProto.proto");
  GOOGLE_CHECK(file != NULL);
  SendMessage__descriptor_ = file->message_type(0);
  static const int SendMessage__offsets_[4] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendMessage_, socket_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendMessage_, buffer_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendMessage_, length_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendMessage_, flags_),
  };
  SendMessage__reflection_ =
    ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection(
      SendMessage__descriptor_,
      SendMessage_::default_instance_,
      SendMessage__offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendMessage_, _has_bits_[0]),
      -1,
      -1,
      sizeof(SendMessage_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendMessage_, _internal_metadata_),
      -1);
  SendToMessage_descriptor_ = file->message_type(1);
  static const int SendToMessage_offsets_[6] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendToMessage, socket_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendToMessage, buffer_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendToMessage, length_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendToMessage, flags_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendToMessage, to_address_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendToMessage, to_length_),
  };
  SendToMessage_reflection_ =
    ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection(
      SendToMessage_descriptor_,
      SendToMessage::default_instance_,
      SendToMessage_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendToMessage, _has_bits_[0]),
      -1,
      -1,
      sizeof(SendToMessage),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendToMessage, _internal_metadata_),
      -1);
  WSASendMessage_descriptor_ = file->message_type(2);
  static const int WSASendMessage_offsets_[8] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WSASendMessage, socket_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WSASendMessage, buffers_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WSASendMessage, buffer_size_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WSASendMessage, count_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WSASendMessage, bytes_sent_address_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WSASendMessage, flags_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WSASendMessage, overlapped_address_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WSASendMessage, overlapped_routine_address_),
  };
  WSASendMessage_reflection_ =
    ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection(
      WSASendMessage_descriptor_,
      WSASendMessage::default_instance_,
      WSASendMessage_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WSASendMessage, _has_bits_[0]),
      -1,
      -1,
      sizeof(WSASendMessage),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WSASendMessage, _internal_metadata_),
      -1);
  WSASendToMessage_descriptor_ = file->message_type(3);
  static const int WSASendToMessage_offsets_[10] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WSASendToMessage, socket_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WSASendToMessage, buffers_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WSASendToMessage, buffer_size_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WSASendToMessage, count_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WSASendToMessage, bytes_sent_address_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WSASendToMessage, flags_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WSASendToMessage, to_address_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WSASendToMessage, to_length_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WSASendToMessage, overlapped_address_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WSASendToMessage, overlapped_routine_address_),
  };
  WSASendToMessage_reflection_ =
    ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection(
      WSASendToMessage_descriptor_,
      WSASendToMessage::default_instance_,
      WSASendToMessage_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WSASendToMessage, _has_bits_[0]),
      -1,
      -1,
      sizeof(WSASendToMessage),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WSASendToMessage, _internal_metadata_),
      -1);
  RecvMessage_descriptor_ = file->message_type(4);
  static const int RecvMessage_offsets_[4] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RecvMessage, socket_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RecvMessage, buffer_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RecvMessage, length_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RecvMessage, flags_),
  };
  RecvMessage_reflection_ =
    ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection(
      RecvMessage_descriptor_,
      RecvMessage::default_instance_,
      RecvMessage_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RecvMessage, _has_bits_[0]),
      -1,
      -1,
      sizeof(RecvMessage),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RecvMessage, _internal_metadata_),
      -1);
  RecvFromMessage_descriptor_ = file->message_type(5);
  static const int RecvFromMessage_offsets_[6] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RecvFromMessage, socket_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RecvFromMessage, buffer_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RecvFromMessage, length_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RecvFromMessage, flags_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RecvFromMessage, from_address_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RecvFromMessage, from_length_address_),
  };
  RecvFromMessage_reflection_ =
    ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection(
      RecvFromMessage_descriptor_,
      RecvFromMessage::default_instance_,
      RecvFromMessage_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RecvFromMessage, _has_bits_[0]),
      -1,
      -1,
      sizeof(RecvFromMessage),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RecvFromMessage, _internal_metadata_),
      -1);
  WSARecvMessage_descriptor_ = file->message_type(6);
  static const int WSARecvMessage_offsets_[8] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WSARecvMessage, socket_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WSARecvMessage, buffers_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WSARecvMessage, buffer_size_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WSARecvMessage, count_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WSARecvMessage, bytes_received_address_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WSARecvMessage, flags_address_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WSARecvMessage, overlapped_address_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WSARecvMessage, overlapped_routine_address_),
  };
  WSARecvMessage_reflection_ =
    ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection(
      WSARecvMessage_descriptor_,
      WSARecvMessage::default_instance_,
      WSARecvMessage_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WSARecvMessage, _has_bits_[0]),
      -1,
      -1,
      sizeof(WSARecvMessage),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WSARecvMessage, _internal_metadata_),
      -1);
  WSARecvFromMessage_descriptor_ = file->message_type(7);
  static const int WSARecvFromMessage_offsets_[10] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WSARecvFromMessage, socket_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WSARecvFromMessage, buffers_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WSARecvFromMessage, buffer_size_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WSARecvFromMessage, count_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WSARecvFromMessage, bytes_received_address_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WSARecvFromMessage, flags_address_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WSARecvFromMessage, from_address_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WSARecvFromMessage, from_length_address_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WSARecvFromMessage, overlapped_address_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WSARecvFromMessage, overlapped_routine_address_),
  };
  WSARecvFromMessage_reflection_ =
    ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection(
      WSARecvFromMessage_descriptor_,
      WSARecvFromMessage::default_instance_,
      WSARecvFromMessage_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WSARecvFromMessage, _has_bits_[0]),
      -1,
      -1,
      sizeof(WSARecvFromMessage),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WSARecvFromMessage, _internal_metadata_),
      -1);
  HekateToClientMessage_descriptor_ = file->message_type(8);
  static const int HekateToClientMessage_offsets_[9] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(HekateToClientMessage, send_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(HekateToClientMessage, sendto_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(HekateToClientMessage, wsasend_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(HekateToClientMessage, wsasendto_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(HekateToClientMessage, recv_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(HekateToClientMessage, recvfrom_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(HekateToClientMessage, wsarecv_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(HekateToClientMessage, wsarecvfrom_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(HekateToClientMessage, filter_message_),
  };
  HekateToClientMessage_reflection_ =
    ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection(
      HekateToClientMessage_descriptor_,
      HekateToClientMessage::default_instance_,
      HekateToClientMessage_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(HekateToClientMessage, _has_bits_[0]),
      -1,
      -1,
      sizeof(HekateToClientMessage),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(HekateToClientMessage, _internal_metadata_),
      -1);
  AcknowledgeMessage_descriptor_ = file->message_type(9);
  static const int AcknowledgeMessage_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AcknowledgeMessage, debug_response_id_),
  };
  AcknowledgeMessage_reflection_ =
    ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection(
      AcknowledgeMessage_descriptor_,
      AcknowledgeMessage::default_instance_,
      AcknowledgeMessage_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AcknowledgeMessage, _has_bits_[0]),
      -1,
      -1,
      sizeof(AcknowledgeMessage),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AcknowledgeMessage, _internal_metadata_),
      -1);
  FilterHitMessage_descriptor_ = file->message_type(10);
  static const int FilterHitMessage_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FilterHitMessage, filter_id_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FilterHitMessage, broken_),
  };
  FilterHitMessage_reflection_ =
    ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection(
      FilterHitMessage_descriptor_,
      FilterHitMessage::default_instance_,
      FilterHitMessage_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FilterHitMessage, _has_bits_[0]),
      -1,
      -1,
      sizeof(FilterHitMessage),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FilterHitMessage, _internal_metadata_),
      -1);
  HekateMessage_descriptor_ = file->message_type(11);
  static const int HekateMessage_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(HekateMessage, hook_info_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(HekateMessage, acknowledge_),
  };
  HekateMessage_reflection_ =
    ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection(
      HekateMessage_descriptor_,
      HekateMessage::default_instance_,
      HekateMessage_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(HekateMessage, _has_bits_[0]),
      -1,
      -1,
      sizeof(HekateMessage),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(HekateMessage, _internal_metadata_),
      -1);
}

namespace {

GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
inline void protobuf_AssignDescriptorsOnce() {
  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
                 &protobuf_AssignDesc_HekateServerProto_2eproto);
}

void protobuf_RegisterTypes(const ::std::string&) {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      SendMessage__descriptor_, &SendMessage_::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      SendToMessage_descriptor_, &SendToMessage::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      WSASendMessage_descriptor_, &WSASendMessage::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      WSASendToMessage_descriptor_, &WSASendToMessage::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      RecvMessage_descriptor_, &RecvMessage::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      RecvFromMessage_descriptor_, &RecvFromMessage::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      WSARecvMessage_descriptor_, &WSARecvMessage::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      WSARecvFromMessage_descriptor_, &WSARecvFromMessage::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      HekateToClientMessage_descriptor_, &HekateToClientMessage::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      AcknowledgeMessage_descriptor_, &AcknowledgeMessage::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      FilterHitMessage_descriptor_, &FilterHitMessage::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      HekateMessage_descriptor_, &HekateMessage::default_instance());
}

}  // namespace

void protobuf_ShutdownFile_HekateServerProto_2eproto() {
  delete SendMessage_::default_instance_;
  delete SendMessage__reflection_;
  delete SendToMessage::default_instance_;
  delete SendToMessage_reflection_;
  delete WSASendMessage::default_instance_;
  delete WSASendMessage_reflection_;
  delete WSASendToMessage::default_instance_;
  delete WSASendToMessage_reflection_;
  delete RecvMessage::default_instance_;
  delete RecvMessage_reflection_;
  delete RecvFromMessage::default_instance_;
  delete RecvFromMessage_reflection_;
  delete WSARecvMessage::default_instance_;
  delete WSARecvMessage_reflection_;
  delete WSARecvFromMessage::default_instance_;
  delete WSARecvFromMessage_reflection_;
  delete HekateToClientMessage::default_instance_;
  delete HekateToClientMessage_reflection_;
  delete AcknowledgeMessage::default_instance_;
  delete AcknowledgeMessage_reflection_;
  delete FilterHitMessage::default_instance_;
  delete FilterHitMessage_reflection_;
  delete HekateMessage::default_instance_;
  delete HekateMessage_reflection_;
}

void protobuf_AddDesc_HekateServerProto_2eproto() {
  static bool already_here = false;
  if (already_here) return;
  already_here = true;
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
    "\n\027HekateServerProto.proto\022\034Hekate.Protob"
    "uf.Proto.Server\"M\n\014SendMessage_\022\016\n\006socke"
    "t\030\001 \002(\003\022\016\n\006buffer\030\002 \002(\014\022\016\n\006length\030\003 \002(\005\022"
    "\r\n\005flags\030\004 \002(\005\"u\n\rSendToMessage\022\016\n\006socke"
    "t\030\001 \002(\003\022\016\n\006buffer\030\002 \002(\014\022\016\n\006length\030\003 \002(\005\022"
    "\r\n\005flags\030\004 \002(\005\022\022\n\nto_address\030\005 \002(\003\022\021\n\tto"
    "_length\030\006 \002(\005\"\300\001\n\016WSASendMessage\022\016\n\006sock"
    "et\030\001 \002(\003\022\017\n\007buffers\030\002 \003(\014\022\023\n\013buffer_size"
    "\030\003 \003(\005\022\r\n\005count\030\004 \002(\005\022\032\n\022bytes_sent_addr"
    "ess\030\005 \002(\003\022\r\n\005flags\030\006 \002(\005\022\032\n\022overlapped_a"
    "ddress\030\007 \002(\003\022\"\n\032overlapped_routine_addre"
    "ss\030\010 \002(\003\"\351\001\n\020WSASendToMessage\022\016\n\006socket\030"
    "\001 \002(\003\022\017\n\007buffers\030\002 \003(\014\022\023\n\013buffer_size\030\003 "
    "\003(\005\022\r\n\005count\030\004 \002(\005\022\032\n\022bytes_sent_address"
    "\030\005 \002(\003\022\r\n\005flags\030\006 \002(\005\022\022\n\nto_address\030\007 \002("
    "\003\022\021\n\tto_length\030\010 \002(\005\022\032\n\022overlapped_addre"
    "ss\030\t \002(\003\022\"\n\032overlapped_routine_address\030\n"
    " \002(\003\"L\n\013RecvMessage\022\016\n\006socket\030\001 \002(\003\022\016\n\006b"
    "uffer\030\002 \002(\003\022\016\n\006length\030\003 \002(\005\022\r\n\005flags\030\004 \002"
    "(\005\"\203\001\n\017RecvFromMessage\022\016\n\006socket\030\001 \002(\003\022\016"
    "\n\006buffer\030\002 \002(\003\022\016\n\006length\030\003 \002(\005\022\r\n\005flags\030"
    "\004 \002(\005\022\024\n\014from_address\030\005 \002(\003\022\033\n\023from_leng"
    "th_address\030\006 \002(\003\"\314\001\n\016WSARecvMessage\022\016\n\006s"
    "ocket\030\001 \002(\003\022\017\n\007buffers\030\002 \003(\003\022\023\n\013buffer_s"
    "ize\030\003 \003(\005\022\r\n\005count\030\004 \002(\005\022\036\n\026bytes_receiv"
    "ed_address\030\005 \002(\003\022\025\n\rflags_address\030\006 \002(\003\022"
    "\032\n\022overlapped_address\030\007 \002(\003\022\"\n\032overlappe"
    "d_routine_address\030\010 \002(\003\"\203\002\n\022WSARecvFromM"
    "essage\022\016\n\006socket\030\001 \002(\003\022\017\n\007buffers\030\002 \003(\003\022"
    "\023\n\013buffer_size\030\003 \003(\005\022\r\n\005count\030\004 \002(\005\022\036\n\026b"
    "ytes_received_address\030\005 \002(\003\022\025\n\rflags_add"
    "ress\030\006 \002(\003\022\024\n\014from_address\030\007 \002(\003\022\033\n\023from"
    "_length_address\030\010 \002(\003\022\032\n\022overlapped_addr"
    "ess\030\t \002(\003\022\"\n\032overlapped_routine_address\030"
    "\n \002(\003\"\330\004\n\025HekateToClientMessage\0228\n\004send\030"
    "\001 \001(\0132*.Hekate.Protobuf.Proto.Server.Sen"
    "dMessage_\022;\n\006sendto\030\002 \001(\0132+.Hekate.Proto"
    "buf.Proto.Server.SendToMessage\022=\n\007wsasen"
    "d\030\003 \001(\0132,.Hekate.Protobuf.Proto.Server.W"
    "SASendMessage\022A\n\twsasendto\030\004 \001(\0132..Hekat"
    "e.Protobuf.Proto.Server.WSASendToMessage"
    "\0227\n\004recv\030\005 \001(\0132).Hekate.Protobuf.Proto.S"
    "erver.RecvMessage\022\?\n\010recvfrom\030\006 \001(\0132-.He"
    "kate.Protobuf.Proto.Server.RecvFromMessa"
    "ge\022=\n\007wsarecv\030\007 \001(\0132,.Hekate.Protobuf.Pr"
    "oto.Server.WSARecvMessage\022E\n\013wsarecvfrom"
    "\030\010 \001(\01320.Hekate.Protobuf.Proto.Server.WS"
    "ARecvFromMessage\022F\n\016filter_message\030\t \001(\013"
    "2..Hekate.Protobuf.Proto.Server.FilterHi"
    "tMessage\"/\n\022AcknowledgeMessage\022\031\n\021debug_"
    "response_id\030\001 \001(\005\"5\n\020FilterHitMessage\022\021\n"
    "\tfilter_id\030\001 \002(\005\022\016\n\006broken\030\002 \002(\010\"\236\001\n\rHek"
    "ateMessage\022F\n\thook_info\030\001 \002(\01323.Hekate.P"
    "rotobuf.Proto.Server.HekateToClientMessa"
    "ge\022E\n\013acknowledge\030\002 \001(\01320.Hekate.Protobu"
    "f.Proto.Server.AcknowledgeMessage", 2233);
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
    "HekateServerProto.proto", &protobuf_RegisterTypes);
  SendMessage_::default_instance_ = new SendMessage_();
  SendToMessage::default_instance_ = new SendToMessage();
  WSASendMessage::default_instance_ = new WSASendMessage();
  WSASendToMessage::default_instance_ = new WSASendToMessage();
  RecvMessage::default_instance_ = new RecvMessage();
  RecvFromMessage::default_instance_ = new RecvFromMessage();
  WSARecvMessage::default_instance_ = new WSARecvMessage();
  WSARecvFromMessage::default_instance_ = new WSARecvFromMessage();
  HekateToClientMessage::default_instance_ = new HekateToClientMessage();
  AcknowledgeMessage::default_instance_ = new AcknowledgeMessage();
  FilterHitMessage::default_instance_ = new FilterHitMessage();
  HekateMessage::default_instance_ = new HekateMessage();
  SendMessage_::default_instance_->InitAsDefaultInstance();
  SendToMessage::default_instance_->InitAsDefaultInstance();
  WSASendMessage::default_instance_->InitAsDefaultInstance();
  WSASendToMessage::default_instance_->InitAsDefaultInstance();
  RecvMessage::default_instance_->InitAsDefaultInstance();
  RecvFromMessage::default_instance_->InitAsDefaultInstance();
  WSARecvMessage::default_instance_->InitAsDefaultInstance();
  WSARecvFromMessage::default_instance_->InitAsDefaultInstance();
  HekateToClientMessage::default_instance_->InitAsDefaultInstance();
  AcknowledgeMessage::default_instance_->InitAsDefaultInstance();
  FilterHitMessage::default_instance_->InitAsDefaultInstance();
  HekateMessage::default_instance_->InitAsDefaultInstance();
  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_HekateServerProto_2eproto);
}

// Force AddDescriptors() to be called at static initialization time.
struct StaticDescriptorInitializer_HekateServerProto_2eproto {
  StaticDescriptorInitializer_HekateServerProto_2eproto() {
    protobuf_AddDesc_HekateServerProto_2eproto();
  }
} static_descriptor_initializer_HekateServerProto_2eproto_;

namespace {

static void MergeFromFail(int line) GOOGLE_ATTRIBUTE_COLD;
static void MergeFromFail(int line) {
  GOOGLE_CHECK(false) << __FILE__ << ":" << line;
}

}  // namespace


// ===================================================================

#ifndef _MSC_VER
const int SendMessage_::kSocketFieldNumber;
const int SendMessage_::kBufferFieldNumber;
const int SendMessage_::kLengthFieldNumber;
const int SendMessage_::kFlagsFieldNumber;
#endif  // !_MSC_VER

SendMessage_::SendMessage_()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:Hekate.Protobuf.Proto.Server.SendMessage_)
}

void SendMessage_::InitAsDefaultInstance() {
}

SendMessage_::SendMessage_(const SendMessage_& from)
  : ::google::protobuf::Message(),
    _internal_metadata_(NULL) {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:Hekate.Protobuf.Proto.Server.SendMessage_)
}

void SendMessage_::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  socket_ = GOOGLE_LONGLONG(0);
  buffer_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  length_ = 0;
  flags_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

SendMessage_::~SendMessage_() {
  // @@protoc_insertion_point(destructor:Hekate.Protobuf.Proto.Server.SendMessage_)
  SharedDtor();
}

void SendMessage_::SharedDtor() {
  buffer_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (this != default_instance_) {
  }
}

void SendMessage_::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* SendMessage_::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return SendMessage__descriptor_;
}

const SendMessage_& SendMessage_::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_HekateServerProto_2eproto();
  return *default_instance_;
}

SendMessage_* SendMessage_::default_instance_ = NULL;

SendMessage_* SendMessage_::New(::google::protobuf::Arena* arena) const {
  SendMessage_* n = new SendMessage_;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void SendMessage_::Clear() {
#define ZR_HELPER_(f) reinterpret_cast<char*>(\
  &reinterpret_cast<SendMessage_*>(16)->f)

#define ZR_(first, last) do {\
  ::memset(&first, 0,\
           ZR_HELPER_(last) - ZR_HELPER_(first) + sizeof(last));\
} while (0)

  if (_has_bits_[0 / 32] & 15u) {
    ZR_(length_, flags_);
    socket_ = GOOGLE_LONGLONG(0);
    if (has_buffer()) {
      buffer_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    }
  }

#undef ZR_HELPER_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  if (_internal_metadata_.have_unknown_fields()) {
    mutable_unknown_fields()->Clear();
  }
}

bool SendMessage_::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:Hekate.Protobuf.Proto.Server.SendMessage_)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required int64 socket = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &socket_)));
          set_has_socket();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_buffer;
        break;
      }

      // required bytes buffer = 2;
      case 2: {
        if (tag == 18) {
         parse_buffer:
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_buffer()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_length;
        break;
      }

      // required int32 length = 3;
      case 3: {
        if (tag == 24) {
         parse_length:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &length_)));
          set_has_length();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(32)) goto parse_flags;
        break;
      }

      // required int32 flags = 4;
      case 4: {
        if (tag == 32) {
         parse_flags:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &flags_)));
          set_has_flags();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:Hekate.Protobuf.Proto.Server.SendMessage_)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:Hekate.Protobuf.Proto.Server.SendMessage_)
  return false;
#undef DO_
}

void SendMessage_::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:Hekate.Protobuf.Proto.Server.SendMessage_)
  // required int64 socket = 1;
  if (has_socket()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(1, this->socket(), output);
  }

  // required bytes buffer = 2;
  if (has_buffer()) {
    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
      2, this->buffer(), output);
  }

  // required int32 length = 3;
  if (has_length()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->length(), output);
  }

  // required int32 flags = 4;
  if (has_flags()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->flags(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:Hekate.Protobuf.Proto.Server.SendMessage_)
}

::google::protobuf::uint8* SendMessage_::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:Hekate.Protobuf.Proto.Server.SendMessage_)
  // required int64 socket = 1;
  if (has_socket()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(1, this->socket(), target);
  }

  // required bytes buffer = 2;
  if (has_buffer()) {
    target =
      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
        2, this->buffer(), target);
  }

  // required int32 length = 3;
  if (has_length()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->length(), target);
  }

  // required int32 flags = 4;
  if (has_flags()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(4, this->flags(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:Hekate.Protobuf.Proto.Server.SendMessage_)
  return target;
}

int SendMessage_::RequiredFieldsByteSizeFallback() const {
  int total_size = 0;

  if (has_socket()) {
    // required int64 socket = 1;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int64Size(
        this->socket());
  }

  if (has_buffer()) {
    // required bytes buffer = 2;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::BytesSize(
        this->buffer());
  }

  if (has_length()) {
    // required int32 length = 3;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int32Size(
        this->length());
  }

  if (has_flags()) {
    // required int32 flags = 4;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int32Size(
        this->flags());
  }

  return total_size;
}
int SendMessage_::ByteSize() const {
  int total_size = 0;

  if (((_has_bits_[0] & 0x0000000f) ^ 0x0000000f) == 0) {  // All required fields are present.
    // required int64 socket = 1;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int64Size(
        this->socket());

    // required bytes buffer = 2;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::BytesSize(
        this->buffer());

    // required int32 length = 3;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int32Size(
        this->length());

    // required int32 flags = 4;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int32Size(
        this->flags());

  } else {
    total_size += RequiredFieldsByteSizeFallback();
  }
  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void SendMessage_::MergeFrom(const ::google::protobuf::Message& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  const SendMessage_* source = 
      ::google::protobuf::internal::DynamicCastToGenerated<const SendMessage_>(
          &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void SendMessage_::MergeFrom(const SendMessage_& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_socket()) {
      set_socket(from.socket());
    }
    if (from.has_buffer()) {
      set_has_buffer();
      buffer_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.buffer_);
    }
    if (from.has_length()) {
      set_length(from.length());
    }
    if (from.has_flags()) {
      set_flags(from.flags());
    }
  }
  if (from._internal_metadata_.have_unknown_fields()) {
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
}

void SendMessage_::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void SendMessage_::CopyFrom(const SendMessage_& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool SendMessage_::IsInitialized() const {
  if ((_has_bits_[0] & 0x0000000f) != 0x0000000f) return false;

  return true;
}

void SendMessage_::Swap(SendMessage_* other) {
  if (other == this) return;
  InternalSwap(other);
}
void SendMessage_::InternalSwap(SendMessage_* other) {
  std::swap(socket_, other->socket_);
  buffer_.Swap(&other->buffer_);
  std::swap(length_, other->length_);
  std::swap(flags_, other->flags_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata SendMessage_::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = SendMessage__descriptor_;
  metadata.reflection = SendMessage__reflection_;
  return metadata;
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// SendMessage_

// required int64 socket = 1;
bool SendMessage_::has_socket() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void SendMessage_::set_has_socket() {
  _has_bits_[0] |= 0x00000001u;
}
void SendMessage_::clear_has_socket() {
  _has_bits_[0] &= ~0x00000001u;
}
void SendMessage_::clear_socket() {
  socket_ = GOOGLE_LONGLONG(0);
  clear_has_socket();
}
 ::google::protobuf::int64 SendMessage_::socket() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Server.SendMessage_.socket)
  return socket_;
}
 void SendMessage_::set_socket(::google::protobuf::int64 value) {
  set_has_socket();
  socket_ = value;
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Server.SendMessage_.socket)
}

// required bytes buffer = 2;
bool SendMessage_::has_buffer() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void SendMessage_::set_has_buffer() {
  _has_bits_[0] |= 0x00000002u;
}
void SendMessage_::clear_has_buffer() {
  _has_bits_[0] &= ~0x00000002u;
}
void SendMessage_::clear_buffer() {
  buffer_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_buffer();
}
 const ::std::string& SendMessage_::buffer() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Server.SendMessage_.buffer)
  return buffer_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
 void SendMessage_::set_buffer(const ::std::string& value) {
  set_has_buffer();
  buffer_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Server.SendMessage_.buffer)
}
 void SendMessage_::set_buffer(const char* value) {
  set_has_buffer();
  buffer_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:Hekate.Protobuf.Proto.Server.SendMessage_.buffer)
}
 void SendMessage_::set_buffer(const void* value, size_t size) {
  set_has_buffer();
  buffer_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:Hekate.Protobuf.Proto.Server.SendMessage_.buffer)
}
 ::std::string* SendMessage_::mutable_buffer() {
  set_has_buffer();
  // @@protoc_insertion_point(field_mutable:Hekate.Protobuf.Proto.Server.SendMessage_.buffer)
  return buffer_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
 ::std::string* SendMessage_::release_buffer() {
  clear_has_buffer();
  return buffer_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
 void SendMessage_::set_allocated_buffer(::std::string* buffer) {
  if (buffer != NULL) {
    set_has_buffer();
  } else {
    clear_has_buffer();
  }
  buffer_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), buffer);
  // @@protoc_insertion_point(field_set_allocated:Hekate.Protobuf.Proto.Server.SendMessage_.buffer)
}

// required int32 length = 3;
bool SendMessage_::has_length() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
void SendMessage_::set_has_length() {
  _has_bits_[0] |= 0x00000004u;
}
void SendMessage_::clear_has_length() {
  _has_bits_[0] &= ~0x00000004u;
}
void SendMessage_::clear_length() {
  length_ = 0;
  clear_has_length();
}
 ::google::protobuf::int32 SendMessage_::length() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Server.SendMessage_.length)
  return length_;
}
 void SendMessage_::set_length(::google::protobuf::int32 value) {
  set_has_length();
  length_ = value;
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Server.SendMessage_.length)
}

// required int32 flags = 4;
bool SendMessage_::has_flags() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
void SendMessage_::set_has_flags() {
  _has_bits_[0] |= 0x00000008u;
}
void SendMessage_::clear_has_flags() {
  _has_bits_[0] &= ~0x00000008u;
}
void SendMessage_::clear_flags() {
  flags_ = 0;
  clear_has_flags();
}
 ::google::protobuf::int32 SendMessage_::flags() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Server.SendMessage_.flags)
  return flags_;
}
 void SendMessage_::set_flags(::google::protobuf::int32 value) {
  set_has_flags();
  flags_ = value;
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Server.SendMessage_.flags)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

// ===================================================================

#ifndef _MSC_VER
const int SendToMessage::kSocketFieldNumber;
const int SendToMessage::kBufferFieldNumber;
const int SendToMessage::kLengthFieldNumber;
const int SendToMessage::kFlagsFieldNumber;
const int SendToMessage::kToAddressFieldNumber;
const int SendToMessage::kToLengthFieldNumber;
#endif  // !_MSC_VER

SendToMessage::SendToMessage()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:Hekate.Protobuf.Proto.Server.SendToMessage)
}

void SendToMessage::InitAsDefaultInstance() {
}

SendToMessage::SendToMessage(const SendToMessage& from)
  : ::google::protobuf::Message(),
    _internal_metadata_(NULL) {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:Hekate.Protobuf.Proto.Server.SendToMessage)
}

void SendToMessage::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  socket_ = GOOGLE_LONGLONG(0);
  buffer_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  length_ = 0;
  flags_ = 0;
  to_address_ = GOOGLE_LONGLONG(0);
  to_length_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

SendToMessage::~SendToMessage() {
  // @@protoc_insertion_point(destructor:Hekate.Protobuf.Proto.Server.SendToMessage)
  SharedDtor();
}

void SendToMessage::SharedDtor() {
  buffer_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (this != default_instance_) {
  }
}

void SendToMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* SendToMessage::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return SendToMessage_descriptor_;
}

const SendToMessage& SendToMessage::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_HekateServerProto_2eproto();
  return *default_instance_;
}

SendToMessage* SendToMessage::default_instance_ = NULL;

SendToMessage* SendToMessage::New(::google::protobuf::Arena* arena) const {
  SendToMessage* n = new SendToMessage;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void SendToMessage::Clear() {
#define ZR_HELPER_(f) reinterpret_cast<char*>(\
  &reinterpret_cast<SendToMessage*>(16)->f)

#define ZR_(first, last) do {\
  ::memset(&first, 0,\
           ZR_HELPER_(last) - ZR_HELPER_(first) + sizeof(last));\
} while (0)

  if (_has_bits_[0 / 32] & 63u) {
    ZR_(length_, to_length_);
    socket_ = GOOGLE_LONGLONG(0);
    if (has_buffer()) {
      buffer_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    }
  }

#undef ZR_HELPER_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  if (_internal_metadata_.have_unknown_fields()) {
    mutable_unknown_fields()->Clear();
  }
}

bool SendToMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:Hekate.Protobuf.Proto.Server.SendToMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required int64 socket = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &socket_)));
          set_has_socket();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_buffer;
        break;
      }

      // required bytes buffer = 2;
      case 2: {
        if (tag == 18) {
         parse_buffer:
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_buffer()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_length;
        break;
      }

      // required int32 length = 3;
      case 3: {
        if (tag == 24) {
         parse_length:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &length_)));
          set_has_length();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(32)) goto parse_flags;
        break;
      }

      // required int32 flags = 4;
      case 4: {
        if (tag == 32) {
         parse_flags:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &flags_)));
          set_has_flags();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(40)) goto parse_to_address;
        break;
      }

      // required int64 to_address = 5;
      case 5: {
        if (tag == 40) {
         parse_to_address:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &to_address_)));
          set_has_to_address();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(48)) goto parse_to_length;
        break;
      }

      // required int32 to_length = 6;
      case 6: {
        if (tag == 48) {
         parse_to_length:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &to_length_)));
          set_has_to_length();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:Hekate.Protobuf.Proto.Server.SendToMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:Hekate.Protobuf.Proto.Server.SendToMessage)
  return false;
#undef DO_
}

void SendToMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:Hekate.Protobuf.Proto.Server.SendToMessage)
  // required int64 socket = 1;
  if (has_socket()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(1, this->socket(), output);
  }

  // required bytes buffer = 2;
  if (has_buffer()) {
    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
      2, this->buffer(), output);
  }

  // required int32 length = 3;
  if (has_length()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->length(), output);
  }

  // required int32 flags = 4;
  if (has_flags()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->flags(), output);
  }

  // required int64 to_address = 5;
  if (has_to_address()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(5, this->to_address(), output);
  }

  // required int32 to_length = 6;
  if (has_to_length()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(6, this->to_length(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:Hekate.Protobuf.Proto.Server.SendToMessage)
}

::google::protobuf::uint8* SendToMessage::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:Hekate.Protobuf.Proto.Server.SendToMessage)
  // required int64 socket = 1;
  if (has_socket()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(1, this->socket(), target);
  }

  // required bytes buffer = 2;
  if (has_buffer()) {
    target =
      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
        2, this->buffer(), target);
  }

  // required int32 length = 3;
  if (has_length()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->length(), target);
  }

  // required int32 flags = 4;
  if (has_flags()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(4, this->flags(), target);
  }

  // required int64 to_address = 5;
  if (has_to_address()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(5, this->to_address(), target);
  }

  // required int32 to_length = 6;
  if (has_to_length()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(6, this->to_length(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:Hekate.Protobuf.Proto.Server.SendToMessage)
  return target;
}

int SendToMessage::RequiredFieldsByteSizeFallback() const {
  int total_size = 0;

  if (has_socket()) {
    // required int64 socket = 1;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int64Size(
        this->socket());
  }

  if (has_buffer()) {
    // required bytes buffer = 2;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::BytesSize(
        this->buffer());
  }

  if (has_length()) {
    // required int32 length = 3;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int32Size(
        this->length());
  }

  if (has_flags()) {
    // required int32 flags = 4;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int32Size(
        this->flags());
  }

  if (has_to_address()) {
    // required int64 to_address = 5;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int64Size(
        this->to_address());
  }

  if (has_to_length()) {
    // required int32 to_length = 6;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int32Size(
        this->to_length());
  }

  return total_size;
}
int SendToMessage::ByteSize() const {
  int total_size = 0;

  if (((_has_bits_[0] & 0x0000003f) ^ 0x0000003f) == 0) {  // All required fields are present.
    // required int64 socket = 1;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int64Size(
        this->socket());

    // required bytes buffer = 2;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::BytesSize(
        this->buffer());

    // required int32 length = 3;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int32Size(
        this->length());

    // required int32 flags = 4;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int32Size(
        this->flags());

    // required int64 to_address = 5;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int64Size(
        this->to_address());

    // required int32 to_length = 6;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int32Size(
        this->to_length());

  } else {
    total_size += RequiredFieldsByteSizeFallback();
  }
  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void SendToMessage::MergeFrom(const ::google::protobuf::Message& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  const SendToMessage* source = 
      ::google::protobuf::internal::DynamicCastToGenerated<const SendToMessage>(
          &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void SendToMessage::MergeFrom(const SendToMessage& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_socket()) {
      set_socket(from.socket());
    }
    if (from.has_buffer()) {
      set_has_buffer();
      buffer_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.buffer_);
    }
    if (from.has_length()) {
      set_length(from.length());
    }
    if (from.has_flags()) {
      set_flags(from.flags());
    }
    if (from.has_to_address()) {
      set_to_address(from.to_address());
    }
    if (from.has_to_length()) {
      set_to_length(from.to_length());
    }
  }
  if (from._internal_metadata_.have_unknown_fields()) {
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
}

void SendToMessage::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void SendToMessage::CopyFrom(const SendToMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool SendToMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x0000003f) != 0x0000003f) return false;

  return true;
}

void SendToMessage::Swap(SendToMessage* other) {
  if (other == this) return;
  InternalSwap(other);
}
void SendToMessage::InternalSwap(SendToMessage* other) {
  std::swap(socket_, other->socket_);
  buffer_.Swap(&other->buffer_);
  std::swap(length_, other->length_);
  std::swap(flags_, other->flags_);
  std::swap(to_address_, other->to_address_);
  std::swap(to_length_, other->to_length_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata SendToMessage::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = SendToMessage_descriptor_;
  metadata.reflection = SendToMessage_reflection_;
  return metadata;
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// SendToMessage

// required int64 socket = 1;
bool SendToMessage::has_socket() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void SendToMessage::set_has_socket() {
  _has_bits_[0] |= 0x00000001u;
}
void SendToMessage::clear_has_socket() {
  _has_bits_[0] &= ~0x00000001u;
}
void SendToMessage::clear_socket() {
  socket_ = GOOGLE_LONGLONG(0);
  clear_has_socket();
}
 ::google::protobuf::int64 SendToMessage::socket() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Server.SendToMessage.socket)
  return socket_;
}
 void SendToMessage::set_socket(::google::protobuf::int64 value) {
  set_has_socket();
  socket_ = value;
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Server.SendToMessage.socket)
}

// required bytes buffer = 2;
bool SendToMessage::has_buffer() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void SendToMessage::set_has_buffer() {
  _has_bits_[0] |= 0x00000002u;
}
void SendToMessage::clear_has_buffer() {
  _has_bits_[0] &= ~0x00000002u;
}
void SendToMessage::clear_buffer() {
  buffer_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_buffer();
}
 const ::std::string& SendToMessage::buffer() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Server.SendToMessage.buffer)
  return buffer_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
 void SendToMessage::set_buffer(const ::std::string& value) {
  set_has_buffer();
  buffer_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Server.SendToMessage.buffer)
}
 void SendToMessage::set_buffer(const char* value) {
  set_has_buffer();
  buffer_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:Hekate.Protobuf.Proto.Server.SendToMessage.buffer)
}
 void SendToMessage::set_buffer(const void* value, size_t size) {
  set_has_buffer();
  buffer_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:Hekate.Protobuf.Proto.Server.SendToMessage.buffer)
}
 ::std::string* SendToMessage::mutable_buffer() {
  set_has_buffer();
  // @@protoc_insertion_point(field_mutable:Hekate.Protobuf.Proto.Server.SendToMessage.buffer)
  return buffer_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
 ::std::string* SendToMessage::release_buffer() {
  clear_has_buffer();
  return buffer_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
 void SendToMessage::set_allocated_buffer(::std::string* buffer) {
  if (buffer != NULL) {
    set_has_buffer();
  } else {
    clear_has_buffer();
  }
  buffer_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), buffer);
  // @@protoc_insertion_point(field_set_allocated:Hekate.Protobuf.Proto.Server.SendToMessage.buffer)
}

// required int32 length = 3;
bool SendToMessage::has_length() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
void SendToMessage::set_has_length() {
  _has_bits_[0] |= 0x00000004u;
}
void SendToMessage::clear_has_length() {
  _has_bits_[0] &= ~0x00000004u;
}
void SendToMessage::clear_length() {
  length_ = 0;
  clear_has_length();
}
 ::google::protobuf::int32 SendToMessage::length() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Server.SendToMessage.length)
  return length_;
}
 void SendToMessage::set_length(::google::protobuf::int32 value) {
  set_has_length();
  length_ = value;
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Server.SendToMessage.length)
}

// required int32 flags = 4;
bool SendToMessage::has_flags() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
void SendToMessage::set_has_flags() {
  _has_bits_[0] |= 0x00000008u;
}
void SendToMessage::clear_has_flags() {
  _has_bits_[0] &= ~0x00000008u;
}
void SendToMessage::clear_flags() {
  flags_ = 0;
  clear_has_flags();
}
 ::google::protobuf::int32 SendToMessage::flags() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Server.SendToMessage.flags)
  return flags_;
}
 void SendToMessage::set_flags(::google::protobuf::int32 value) {
  set_has_flags();
  flags_ = value;
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Server.SendToMessage.flags)
}

// required int64 to_address = 5;
bool SendToMessage::has_to_address() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
void SendToMessage::set_has_to_address() {
  _has_bits_[0] |= 0x00000010u;
}
void SendToMessage::clear_has_to_address() {
  _has_bits_[0] &= ~0x00000010u;
}
void SendToMessage::clear_to_address() {
  to_address_ = GOOGLE_LONGLONG(0);
  clear_has_to_address();
}
 ::google::protobuf::int64 SendToMessage::to_address() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Server.SendToMessage.to_address)
  return to_address_;
}
 void SendToMessage::set_to_address(::google::protobuf::int64 value) {
  set_has_to_address();
  to_address_ = value;
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Server.SendToMessage.to_address)
}

// required int32 to_length = 6;
bool SendToMessage::has_to_length() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
void SendToMessage::set_has_to_length() {
  _has_bits_[0] |= 0x00000020u;
}
void SendToMessage::clear_has_to_length() {
  _has_bits_[0] &= ~0x00000020u;
}
void SendToMessage::clear_to_length() {
  to_length_ = 0;
  clear_has_to_length();
}
 ::google::protobuf::int32 SendToMessage::to_length() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Server.SendToMessage.to_length)
  return to_length_;
}
 void SendToMessage::set_to_length(::google::protobuf::int32 value) {
  set_has_to_length();
  to_length_ = value;
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Server.SendToMessage.to_length)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

// ===================================================================

#ifndef _MSC_VER
const int WSASendMessage::kSocketFieldNumber;
const int WSASendMessage::kBuffersFieldNumber;
const int WSASendMessage::kBufferSizeFieldNumber;
const int WSASendMessage::kCountFieldNumber;
const int WSASendMessage::kBytesSentAddressFieldNumber;
const int WSASendMessage::kFlagsFieldNumber;
const int WSASendMessage::kOverlappedAddressFieldNumber;
const int WSASendMessage::kOverlappedRoutineAddressFieldNumber;
#endif  // !_MSC_VER

WSASendMessage::WSASendMessage()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:Hekate.Protobuf.Proto.Server.WSASendMessage)
}

void WSASendMessage::InitAsDefaultInstance() {
}

WSASendMessage::WSASendMessage(const WSASendMessage& from)
  : ::google::protobuf::Message(),
    _internal_metadata_(NULL) {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:Hekate.Protobuf.Proto.Server.WSASendMessage)
}

void WSASendMessage::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  socket_ = GOOGLE_LONGLONG(0);
  count_ = 0;
  bytes_sent_address_ = GOOGLE_LONGLONG(0);
  flags_ = 0;
  overlapped_address_ = GOOGLE_LONGLONG(0);
  overlapped_routine_address_ = GOOGLE_LONGLONG(0);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

WSASendMessage::~WSASendMessage() {
  // @@protoc_insertion_point(destructor:Hekate.Protobuf.Proto.Server.WSASendMessage)
  SharedDtor();
}

void WSASendMessage::SharedDtor() {
  if (this != default_instance_) {
  }
}

void WSASendMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* WSASendMessage::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return WSASendMessage_descriptor_;
}

const WSASendMessage& WSASendMessage::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_HekateServerProto_2eproto();
  return *default_instance_;
}

WSASendMessage* WSASendMessage::default_instance_ = NULL;

WSASendMessage* WSASendMessage::New(::google::protobuf::Arena* arena) const {
  WSASendMessage* n = new WSASendMessage;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void WSASendMessage::Clear() {
#define ZR_HELPER_(f) reinterpret_cast<char*>(\
  &reinterpret_cast<WSASendMessage*>(16)->f)

#define ZR_(first, last) do {\
  ::memset(&first, 0,\
           ZR_HELPER_(last) - ZR_HELPER_(first) + sizeof(last));\
} while (0)

  if (_has_bits_[0 / 32] & 249u) {
    ZR_(bytes_sent_address_, overlapped_routine_address_);
    socket_ = GOOGLE_LONGLONG(0);
  }

#undef ZR_HELPER_
#undef ZR_

  buffers_.Clear();
  buffer_size_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  if (_internal_metadata_.have_unknown_fields()) {
    mutable_unknown_fields()->Clear();
  }
}

bool WSASendMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:Hekate.Protobuf.Proto.Server.WSASendMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required int64 socket = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &socket_)));
          set_has_socket();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_buffers;
        break;
      }

      // repeated bytes buffers = 2;
      case 2: {
        if (tag == 18) {
         parse_buffers:
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->add_buffers()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_buffers;
        if (input->ExpectTag(24)) goto parse_buffer_size;
        break;
      }

      // repeated int32 buffer_size = 3;
      case 3: {
        if (tag == 24) {
         parse_buffer_size:
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 1, 24, input, this->mutable_buffer_size())));
        } else if (tag == 26) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, this->mutable_buffer_size())));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_buffer_size;
        if (input->ExpectTag(32)) goto parse_count;
        break;
      }

      // required int32 count = 4;
      case 4: {
        if (tag == 32) {
         parse_count:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &count_)));
          set_has_count();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(40)) goto parse_bytes_sent_address;
        break;
      }

      // required int64 bytes_sent_address = 5;
      case 5: {
        if (tag == 40) {
         parse_bytes_sent_address:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &bytes_sent_address_)));
          set_has_bytes_sent_address();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(48)) goto parse_flags;
        break;
      }

      // required int32 flags = 6;
      case 6: {
        if (tag == 48) {
         parse_flags:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &flags_)));
          set_has_flags();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(56)) goto parse_overlapped_address;
        break;
      }

      // required int64 overlapped_address = 7;
      case 7: {
        if (tag == 56) {
         parse_overlapped_address:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &overlapped_address_)));
          set_has_overlapped_address();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(64)) goto parse_overlapped_routine_address;
        break;
      }

      // required int64 overlapped_routine_address = 8;
      case 8: {
        if (tag == 64) {
         parse_overlapped_routine_address:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &overlapped_routine_address_)));
          set_has_overlapped_routine_address();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:Hekate.Protobuf.Proto.Server.WSASendMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:Hekate.Protobuf.Proto.Server.WSASendMessage)
  return false;
#undef DO_
}

void WSASendMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:Hekate.Protobuf.Proto.Server.WSASendMessage)
  // required int64 socket = 1;
  if (has_socket()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(1, this->socket(), output);
  }

  // repeated bytes buffers = 2;
  for (int i = 0; i < this->buffers_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteBytes(
      2, this->buffers(i), output);
  }

  // repeated int32 buffer_size = 3;
  for (int i = 0; i < this->buffer_size_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(
      3, this->buffer_size(i), output);
  }

  // required int32 count = 4;
  if (has_count()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->count(), output);
  }

  // required int64 bytes_sent_address = 5;
  if (has_bytes_sent_address()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(5, this->bytes_sent_address(), output);
  }

  // required int32 flags = 6;
  if (has_flags()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(6, this->flags(), output);
  }

  // required int64 overlapped_address = 7;
  if (has_overlapped_address()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(7, this->overlapped_address(), output);
  }

  // required int64 overlapped_routine_address = 8;
  if (has_overlapped_routine_address()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(8, this->overlapped_routine_address(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:Hekate.Protobuf.Proto.Server.WSASendMessage)
}

::google::protobuf::uint8* WSASendMessage::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:Hekate.Protobuf.Proto.Server.WSASendMessage)
  // required int64 socket = 1;
  if (has_socket()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(1, this->socket(), target);
  }

  // repeated bytes buffers = 2;
  for (int i = 0; i < this->buffers_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteBytesToArray(2, this->buffers(i), target);
  }

  // repeated int32 buffer_size = 3;
  for (int i = 0; i < this->buffer_size_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteInt32ToArray(3, this->buffer_size(i), target);
  }

  // required int32 count = 4;
  if (has_count()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(4, this->count(), target);
  }

  // required int64 bytes_sent_address = 5;
  if (has_bytes_sent_address()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(5, this->bytes_sent_address(), target);
  }

  // required int32 flags = 6;
  if (has_flags()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(6, this->flags(), target);
  }

  // required int64 overlapped_address = 7;
  if (has_overlapped_address()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(7, this->overlapped_address(), target);
  }

  // required int64 overlapped_routine_address = 8;
  if (has_overlapped_routine_address()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(8, this->overlapped_routine_address(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:Hekate.Protobuf.Proto.Server.WSASendMessage)
  return target;
}

int WSASendMessage::RequiredFieldsByteSizeFallback() const {
  int total_size = 0;

  if (has_socket()) {
    // required int64 socket = 1;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int64Size(
        this->socket());
  }

  if (has_count()) {
    // required int32 count = 4;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int32Size(
        this->count());
  }

  if (has_bytes_sent_address()) {
    // required int64 bytes_sent_address = 5;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int64Size(
        this->bytes_sent_address());
  }

  if (has_flags()) {
    // required int32 flags = 6;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int32Size(
        this->flags());
  }

  if (has_overlapped_address()) {
    // required int64 overlapped_address = 7;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int64Size(
        this->overlapped_address());
  }

  if (has_overlapped_routine_address()) {
    // required int64 overlapped_routine_address = 8;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int64Size(
        this->overlapped_routine_address());
  }

  return total_size;
}
int WSASendMessage::ByteSize() const {
  int total_size = 0;

  if (((_has_bits_[0] & 0x000000f9) ^ 0x000000f9) == 0) {  // All required fields are present.
    // required int64 socket = 1;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int64Size(
        this->socket());

    // required int32 count = 4;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int32Size(
        this->count());

    // required int64 bytes_sent_address = 5;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int64Size(
        this->bytes_sent_address());

    // required int32 flags = 6;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int32Size(
        this->flags());

    // required int64 overlapped_address = 7;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int64Size(
        this->overlapped_address());

    // required int64 overlapped_routine_address = 8;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int64Size(
        this->overlapped_routine_address());

  } else {
    total_size += RequiredFieldsByteSizeFallback();
  }
  // repeated bytes buffers = 2;
  total_size += 1 * this->buffers_size();
  for (int i = 0; i < this->buffers_size(); i++) {
    total_size += ::google::protobuf::internal::WireFormatLite::BytesSize(
      this->buffers(i));
  }

  // repeated int32 buffer_size = 3;
  {
    int data_size = 0;
    for (int i = 0; i < this->buffer_size_size(); i++) {
      data_size += ::google::protobuf::internal::WireFormatLite::
        Int32Size(this->buffer_size(i));
    }
    total_size += 1 * this->buffer_size_size() + data_size;
  }

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void WSASendMessage::MergeFrom(const ::google::protobuf::Message& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  const WSASendMessage* source = 
      ::google::protobuf::internal::DynamicCastToGenerated<const WSASendMessage>(
          &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void WSASendMessage::MergeFrom(const WSASendMessage& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  buffers_.MergeFrom(from.buffers_);
  buffer_size_.MergeFrom(from.buffer_size_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_socket()) {
      set_socket(from.socket());
    }
    if (from.has_count()) {
      set_count(from.count());
    }
    if (from.has_bytes_sent_address()) {
      set_bytes_sent_address(from.bytes_sent_address());
    }
    if (from.has_flags()) {
      set_flags(from.flags());
    }
    if (from.has_overlapped_address()) {
      set_overlapped_address(from.overlapped_address());
    }
    if (from.has_overlapped_routine_address()) {
      set_overlapped_routine_address(from.overlapped_routine_address());
    }
  }
  if (from._internal_metadata_.have_unknown_fields()) {
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
}

void WSASendMessage::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void WSASendMessage::CopyFrom(const WSASendMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool WSASendMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x000000f9) != 0x000000f9) return false;

  return true;
}

void WSASendMessage::Swap(WSASendMessage* other) {
  if (other == this) return;
  InternalSwap(other);
}
void WSASendMessage::InternalSwap(WSASendMessage* other) {
  std::swap(socket_, other->socket_);
  buffers_.UnsafeArenaSwap(&other->buffers_);
  buffer_size_.UnsafeArenaSwap(&other->buffer_size_);
  std::swap(count_, other->count_);
  std::swap(bytes_sent_address_, other->bytes_sent_address_);
  std::swap(flags_, other->flags_);
  std::swap(overlapped_address_, other->overlapped_address_);
  std::swap(overlapped_routine_address_, other->overlapped_routine_address_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata WSASendMessage::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = WSASendMessage_descriptor_;
  metadata.reflection = WSASendMessage_reflection_;
  return metadata;
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// WSASendMessage

// required int64 socket = 1;
bool WSASendMessage::has_socket() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void WSASendMessage::set_has_socket() {
  _has_bits_[0] |= 0x00000001u;
}
void WSASendMessage::clear_has_socket() {
  _has_bits_[0] &= ~0x00000001u;
}
void WSASendMessage::clear_socket() {
  socket_ = GOOGLE_LONGLONG(0);
  clear_has_socket();
}
 ::google::protobuf::int64 WSASendMessage::socket() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Server.WSASendMessage.socket)
  return socket_;
}
 void WSASendMessage::set_socket(::google::protobuf::int64 value) {
  set_has_socket();
  socket_ = value;
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Server.WSASendMessage.socket)
}

// repeated bytes buffers = 2;
int WSASendMessage::buffers_size() const {
  return buffers_.size();
}
void WSASendMessage::clear_buffers() {
  buffers_.Clear();
}
 const ::std::string& WSASendMessage::buffers(int index) const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Server.WSASendMessage.buffers)
  return buffers_.Get(index);
}
 ::std::string* WSASendMessage::mutable_buffers(int index) {
  // @@protoc_insertion_point(field_mutable:Hekate.Protobuf.Proto.Server.WSASendMessage.buffers)
  return buffers_.Mutable(index);
}
 void WSASendMessage::set_buffers(int index, const ::std::string& value) {
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Server.WSASendMessage.buffers)
  buffers_.Mutable(index)->assign(value);
}
 void WSASendMessage::set_buffers(int index, const char* value) {
  buffers_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:Hekate.Protobuf.Proto.Server.WSASendMessage.buffers)
}
 void WSASendMessage::set_buffers(int index, const void* value, size_t size) {
  buffers_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:Hekate.Protobuf.Proto.Server.WSASendMessage.buffers)
}
 ::std::string* WSASendMessage::add_buffers() {
  return buffers_.Add();
}
 void WSASendMessage::add_buffers(const ::std::string& value) {
  buffers_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:Hekate.Protobuf.Proto.Server.WSASendMessage.buffers)
}
 void WSASendMessage::add_buffers(const char* value) {
  buffers_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:Hekate.Protobuf.Proto.Server.WSASendMessage.buffers)
}
 void WSASendMessage::add_buffers(const void* value, size_t size) {
  buffers_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:Hekate.Protobuf.Proto.Server.WSASendMessage.buffers)
}
 const ::google::protobuf::RepeatedPtrField< ::std::string>&
WSASendMessage::buffers() const {
  // @@protoc_insertion_point(field_list:Hekate.Protobuf.Proto.Server.WSASendMessage.buffers)
  return buffers_;
}
 ::google::protobuf::RepeatedPtrField< ::std::string>*
WSASendMessage::mutable_buffers() {
  // @@protoc_insertion_point(field_mutable_list:Hekate.Protobuf.Proto.Server.WSASendMessage.buffers)
  return &buffers_;
}

// repeated int32 buffer_size = 3;
int WSASendMessage::buffer_size_size() const {
  return buffer_size_.size();
}
void WSASendMessage::clear_buffer_size() {
  buffer_size_.Clear();
}
 ::google::protobuf::int32 WSASendMessage::buffer_size(int index) const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Server.WSASendMessage.buffer_size)
  return buffer_size_.Get(index);
}
 void WSASendMessage::set_buffer_size(int index, ::google::protobuf::int32 value) {
  buffer_size_.Set(index, value);
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Server.WSASendMessage.buffer_size)
}
 void WSASendMessage::add_buffer_size(::google::protobuf::int32 value) {
  buffer_size_.Add(value);
  // @@protoc_insertion_point(field_add:Hekate.Protobuf.Proto.Server.WSASendMessage.buffer_size)
}
 const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
WSASendMessage::buffer_size() const {
  // @@protoc_insertion_point(field_list:Hekate.Protobuf.Proto.Server.WSASendMessage.buffer_size)
  return buffer_size_;
}
 ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
WSASendMessage::mutable_buffer_size() {
  // @@protoc_insertion_point(field_mutable_list:Hekate.Protobuf.Proto.Server.WSASendMessage.buffer_size)
  return &buffer_size_;
}

// required int32 count = 4;
bool WSASendMessage::has_count() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
void WSASendMessage::set_has_count() {
  _has_bits_[0] |= 0x00000008u;
}
void WSASendMessage::clear_has_count() {
  _has_bits_[0] &= ~0x00000008u;
}
void WSASendMessage::clear_count() {
  count_ = 0;
  clear_has_count();
}
 ::google::protobuf::int32 WSASendMessage::count() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Server.WSASendMessage.count)
  return count_;
}
 void WSASendMessage::set_count(::google::protobuf::int32 value) {
  set_has_count();
  count_ = value;
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Server.WSASendMessage.count)
}

// required int64 bytes_sent_address = 5;
bool WSASendMessage::has_bytes_sent_address() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
void WSASendMessage::set_has_bytes_sent_address() {
  _has_bits_[0] |= 0x00000010u;
}
void WSASendMessage::clear_has_bytes_sent_address() {
  _has_bits_[0] &= ~0x00000010u;
}
void WSASendMessage::clear_bytes_sent_address() {
  bytes_sent_address_ = GOOGLE_LONGLONG(0);
  clear_has_bytes_sent_address();
}
 ::google::protobuf::int64 WSASendMessage::bytes_sent_address() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Server.WSASendMessage.bytes_sent_address)
  return bytes_sent_address_;
}
 void WSASendMessage::set_bytes_sent_address(::google::protobuf::int64 value) {
  set_has_bytes_sent_address();
  bytes_sent_address_ = value;
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Server.WSASendMessage.bytes_sent_address)
}

// required int32 flags = 6;
bool WSASendMessage::has_flags() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
void WSASendMessage::set_has_flags() {
  _has_bits_[0] |= 0x00000020u;
}
void WSASendMessage::clear_has_flags() {
  _has_bits_[0] &= ~0x00000020u;
}
void WSASendMessage::clear_flags() {
  flags_ = 0;
  clear_has_flags();
}
 ::google::protobuf::int32 WSASendMessage::flags() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Server.WSASendMessage.flags)
  return flags_;
}
 void WSASendMessage::set_flags(::google::protobuf::int32 value) {
  set_has_flags();
  flags_ = value;
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Server.WSASendMessage.flags)
}

// required int64 overlapped_address = 7;
bool WSASendMessage::has_overlapped_address() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
void WSASendMessage::set_has_overlapped_address() {
  _has_bits_[0] |= 0x00000040u;
}
void WSASendMessage::clear_has_overlapped_address() {
  _has_bits_[0] &= ~0x00000040u;
}
void WSASendMessage::clear_overlapped_address() {
  overlapped_address_ = GOOGLE_LONGLONG(0);
  clear_has_overlapped_address();
}
 ::google::protobuf::int64 WSASendMessage::overlapped_address() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Server.WSASendMessage.overlapped_address)
  return overlapped_address_;
}
 void WSASendMessage::set_overlapped_address(::google::protobuf::int64 value) {
  set_has_overlapped_address();
  overlapped_address_ = value;
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Server.WSASendMessage.overlapped_address)
}

// required int64 overlapped_routine_address = 8;
bool WSASendMessage::has_overlapped_routine_address() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
void WSASendMessage::set_has_overlapped_routine_address() {
  _has_bits_[0] |= 0x00000080u;
}
void WSASendMessage::clear_has_overlapped_routine_address() {
  _has_bits_[0] &= ~0x00000080u;
}
void WSASendMessage::clear_overlapped_routine_address() {
  overlapped_routine_address_ = GOOGLE_LONGLONG(0);
  clear_has_overlapped_routine_address();
}
 ::google::protobuf::int64 WSASendMessage::overlapped_routine_address() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Server.WSASendMessage.overlapped_routine_address)
  return overlapped_routine_address_;
}
 void WSASendMessage::set_overlapped_routine_address(::google::protobuf::int64 value) {
  set_has_overlapped_routine_address();
  overlapped_routine_address_ = value;
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Server.WSASendMessage.overlapped_routine_address)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

// ===================================================================

#ifndef _MSC_VER
const int WSASendToMessage::kSocketFieldNumber;
const int WSASendToMessage::kBuffersFieldNumber;
const int WSASendToMessage::kBufferSizeFieldNumber;
const int WSASendToMessage::kCountFieldNumber;
const int WSASendToMessage::kBytesSentAddressFieldNumber;
const int WSASendToMessage::kFlagsFieldNumber;
const int WSASendToMessage::kToAddressFieldNumber;
const int WSASendToMessage::kToLengthFieldNumber;
const int WSASendToMessage::kOverlappedAddressFieldNumber;
const int WSASendToMessage::kOverlappedRoutineAddressFieldNumber;
#endif  // !_MSC_VER

WSASendToMessage::WSASendToMessage()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:Hekate.Protobuf.Proto.Server.WSASendToMessage)
}

void WSASendToMessage::InitAsDefaultInstance() {
}

WSASendToMessage::WSASendToMessage(const WSASendToMessage& from)
  : ::google::protobuf::Message(),
    _internal_metadata_(NULL) {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:Hekate.Protobuf.Proto.Server.WSASendToMessage)
}

void WSASendToMessage::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  socket_ = GOOGLE_LONGLONG(0);
  count_ = 0;
  bytes_sent_address_ = GOOGLE_LONGLONG(0);
  flags_ = 0;
  to_address_ = GOOGLE_LONGLONG(0);
  to_length_ = 0;
  overlapped_address_ = GOOGLE_LONGLONG(0);
  overlapped_routine_address_ = GOOGLE_LONGLONG(0);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

WSASendToMessage::~WSASendToMessage() {
  // @@protoc_insertion_point(destructor:Hekate.Protobuf.Proto.Server.WSASendToMessage)
  SharedDtor();
}

void WSASendToMessage::SharedDtor() {
  if (this != default_instance_) {
  }
}

void WSASendToMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* WSASendToMessage::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return WSASendToMessage_descriptor_;
}

const WSASendToMessage& WSASendToMessage::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_HekateServerProto_2eproto();
  return *default_instance_;
}

WSASendToMessage* WSASendToMessage::default_instance_ = NULL;

WSASendToMessage* WSASendToMessage::New(::google::protobuf::Arena* arena) const {
  WSASendToMessage* n = new WSASendToMessage;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void WSASendToMessage::Clear() {
#define ZR_HELPER_(f) reinterpret_cast<char*>(\
  &reinterpret_cast<WSASendToMessage*>(16)->f)

#define ZR_(first, last) do {\
  ::memset(&first, 0,\
           ZR_HELPER_(last) - ZR_HELPER_(first) + sizeof(last));\
} while (0)

  if (_has_bits_[0 / 32] & 249u) {
    ZR_(bytes_sent_address_, to_address_);
    socket_ = GOOGLE_LONGLONG(0);
    to_length_ = 0;
  }
  ZR_(overlapped_address_, overlapped_routine_address_);

#undef ZR_HELPER_
#undef ZR_

  buffers_.Clear();
  buffer_size_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  if (_internal_metadata_.have_unknown_fields()) {
    mutable_unknown_fields()->Clear();
  }
}

bool WSASendToMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:Hekate.Protobuf.Proto.Server.WSASendToMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required int64 socket = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &socket_)));
          set_has_socket();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_buffers;
        break;
      }

      // repeated bytes buffers = 2;
      case 2: {
        if (tag == 18) {
         parse_buffers:
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->add_buffers()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_buffers;
        if (input->ExpectTag(24)) goto parse_buffer_size;
        break;
      }

      // repeated int32 buffer_size = 3;
      case 3: {
        if (tag == 24) {
         parse_buffer_size:
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 1, 24, input, this->mutable_buffer_size())));
        } else if (tag == 26) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, this->mutable_buffer_size())));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_buffer_size;
        if (input->ExpectTag(32)) goto parse_count;
        break;
      }

      // required int32 count = 4;
      case 4: {
        if (tag == 32) {
         parse_count:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &count_)));
          set_has_count();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(40)) goto parse_bytes_sent_address;
        break;
      }

      // required int64 bytes_sent_address = 5;
      case 5: {
        if (tag == 40) {
         parse_bytes_sent_address:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &bytes_sent_address_)));
          set_has_bytes_sent_address();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(48)) goto parse_flags;
        break;
      }

      // required int32 flags = 6;
      case 6: {
        if (tag == 48) {
         parse_flags:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &flags_)));
          set_has_flags();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(56)) goto parse_to_address;
        break;
      }

      // required int64 to_address = 7;
      case 7: {
        if (tag == 56) {
         parse_to_address:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &to_address_)));
          set_has_to_address();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(64)) goto parse_to_length;
        break;
      }

      // required int32 to_length = 8;
      case 8: {
        if (tag == 64) {
         parse_to_length:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &to_length_)));
          set_has_to_length();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(72)) goto parse_overlapped_address;
        break;
      }

      // required int64 overlapped_address = 9;
      case 9: {
        if (tag == 72) {
         parse_overlapped_address:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &overlapped_address_)));
          set_has_overlapped_address();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(80)) goto parse_overlapped_routine_address;
        break;
      }

      // required int64 overlapped_routine_address = 10;
      case 10: {
        if (tag == 80) {
         parse_overlapped_routine_address:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &overlapped_routine_address_)));
          set_has_overlapped_routine_address();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:Hekate.Protobuf.Proto.Server.WSASendToMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:Hekate.Protobuf.Proto.Server.WSASendToMessage)
  return false;
#undef DO_
}

void WSASendToMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:Hekate.Protobuf.Proto.Server.WSASendToMessage)
  // required int64 socket = 1;
  if (has_socket()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(1, this->socket(), output);
  }

  // repeated bytes buffers = 2;
  for (int i = 0; i < this->buffers_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteBytes(
      2, this->buffers(i), output);
  }

  // repeated int32 buffer_size = 3;
  for (int i = 0; i < this->buffer_size_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(
      3, this->buffer_size(i), output);
  }

  // required int32 count = 4;
  if (has_count()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->count(), output);
  }

  // required int64 bytes_sent_address = 5;
  if (has_bytes_sent_address()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(5, this->bytes_sent_address(), output);
  }

  // required int32 flags = 6;
  if (has_flags()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(6, this->flags(), output);
  }

  // required int64 to_address = 7;
  if (has_to_address()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(7, this->to_address(), output);
  }

  // required int32 to_length = 8;
  if (has_to_length()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(8, this->to_length(), output);
  }

  // required int64 overlapped_address = 9;
  if (has_overlapped_address()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(9, this->overlapped_address(), output);
  }

  // required int64 overlapped_routine_address = 10;
  if (has_overlapped_routine_address()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(10, this->overlapped_routine_address(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:Hekate.Protobuf.Proto.Server.WSASendToMessage)
}

::google::protobuf::uint8* WSASendToMessage::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:Hekate.Protobuf.Proto.Server.WSASendToMessage)
  // required int64 socket = 1;
  if (has_socket()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(1, this->socket(), target);
  }

  // repeated bytes buffers = 2;
  for (int i = 0; i < this->buffers_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteBytesToArray(2, this->buffers(i), target);
  }

  // repeated int32 buffer_size = 3;
  for (int i = 0; i < this->buffer_size_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteInt32ToArray(3, this->buffer_size(i), target);
  }

  // required int32 count = 4;
  if (has_count()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(4, this->count(), target);
  }

  // required int64 bytes_sent_address = 5;
  if (has_bytes_sent_address()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(5, this->bytes_sent_address(), target);
  }

  // required int32 flags = 6;
  if (has_flags()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(6, this->flags(), target);
  }

  // required int64 to_address = 7;
  if (has_to_address()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(7, this->to_address(), target);
  }

  // required int32 to_length = 8;
  if (has_to_length()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(8, this->to_length(), target);
  }

  // required int64 overlapped_address = 9;
  if (has_overlapped_address()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(9, this->overlapped_address(), target);
  }

  // required int64 overlapped_routine_address = 10;
  if (has_overlapped_routine_address()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(10, this->overlapped_routine_address(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:Hekate.Protobuf.Proto.Server.WSASendToMessage)
  return target;
}

int WSASendToMessage::RequiredFieldsByteSizeFallback() const {
  int total_size = 0;

  if (has_socket()) {
    // required int64 socket = 1;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int64Size(
        this->socket());
  }

  if (has_count()) {
    // required int32 count = 4;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int32Size(
        this->count());
  }

  if (has_bytes_sent_address()) {
    // required int64 bytes_sent_address = 5;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int64Size(
        this->bytes_sent_address());
  }

  if (has_flags()) {
    // required int32 flags = 6;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int32Size(
        this->flags());
  }

  if (has_to_address()) {
    // required int64 to_address = 7;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int64Size(
        this->to_address());
  }

  if (has_to_length()) {
    // required int32 to_length = 8;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int32Size(
        this->to_length());
  }

  if (has_overlapped_address()) {
    // required int64 overlapped_address = 9;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int64Size(
        this->overlapped_address());
  }

  if (has_overlapped_routine_address()) {
    // required int64 overlapped_routine_address = 10;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int64Size(
        this->overlapped_routine_address());
  }

  return total_size;
}
int WSASendToMessage::ByteSize() const {
  int total_size = 0;

  if (((_has_bits_[0] & 0x000003f9) ^ 0x000003f9) == 0) {  // All required fields are present.
    // required int64 socket = 1;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int64Size(
        this->socket());

    // required int32 count = 4;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int32Size(
        this->count());

    // required int64 bytes_sent_address = 5;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int64Size(
        this->bytes_sent_address());

    // required int32 flags = 6;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int32Size(
        this->flags());

    // required int64 to_address = 7;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int64Size(
        this->to_address());

    // required int32 to_length = 8;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int32Size(
        this->to_length());

    // required int64 overlapped_address = 9;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int64Size(
        this->overlapped_address());

    // required int64 overlapped_routine_address = 10;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int64Size(
        this->overlapped_routine_address());

  } else {
    total_size += RequiredFieldsByteSizeFallback();
  }
  // repeated bytes buffers = 2;
  total_size += 1 * this->buffers_size();
  for (int i = 0; i < this->buffers_size(); i++) {
    total_size += ::google::protobuf::internal::WireFormatLite::BytesSize(
      this->buffers(i));
  }

  // repeated int32 buffer_size = 3;
  {
    int data_size = 0;
    for (int i = 0; i < this->buffer_size_size(); i++) {
      data_size += ::google::protobuf::internal::WireFormatLite::
        Int32Size(this->buffer_size(i));
    }
    total_size += 1 * this->buffer_size_size() + data_size;
  }

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void WSASendToMessage::MergeFrom(const ::google::protobuf::Message& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  const WSASendToMessage* source = 
      ::google::protobuf::internal::DynamicCastToGenerated<const WSASendToMessage>(
          &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void WSASendToMessage::MergeFrom(const WSASendToMessage& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  buffers_.MergeFrom(from.buffers_);
  buffer_size_.MergeFrom(from.buffer_size_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_socket()) {
      set_socket(from.socket());
    }
    if (from.has_count()) {
      set_count(from.count());
    }
    if (from.has_bytes_sent_address()) {
      set_bytes_sent_address(from.bytes_sent_address());
    }
    if (from.has_flags()) {
      set_flags(from.flags());
    }
    if (from.has_to_address()) {
      set_to_address(from.to_address());
    }
    if (from.has_to_length()) {
      set_to_length(from.to_length());
    }
  }
  if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
    if (from.has_overlapped_address()) {
      set_overlapped_address(from.overlapped_address());
    }
    if (from.has_overlapped_routine_address()) {
      set_overlapped_routine_address(from.overlapped_routine_address());
    }
  }
  if (from._internal_metadata_.have_unknown_fields()) {
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
}

void WSASendToMessage::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void WSASendToMessage::CopyFrom(const WSASendToMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool WSASendToMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x000003f9) != 0x000003f9) return false;

  return true;
}

void WSASendToMessage::Swap(WSASendToMessage* other) {
  if (other == this) return;
  InternalSwap(other);
}
void WSASendToMessage::InternalSwap(WSASendToMessage* other) {
  std::swap(socket_, other->socket_);
  buffers_.UnsafeArenaSwap(&other->buffers_);
  buffer_size_.UnsafeArenaSwap(&other->buffer_size_);
  std::swap(count_, other->count_);
  std::swap(bytes_sent_address_, other->bytes_sent_address_);
  std::swap(flags_, other->flags_);
  std::swap(to_address_, other->to_address_);
  std::swap(to_length_, other->to_length_);
  std::swap(overlapped_address_, other->overlapped_address_);
  std::swap(overlapped_routine_address_, other->overlapped_routine_address_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata WSASendToMessage::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = WSASendToMessage_descriptor_;
  metadata.reflection = WSASendToMessage_reflection_;
  return metadata;
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// WSASendToMessage

// required int64 socket = 1;
bool WSASendToMessage::has_socket() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void WSASendToMessage::set_has_socket() {
  _has_bits_[0] |= 0x00000001u;
}
void WSASendToMessage::clear_has_socket() {
  _has_bits_[0] &= ~0x00000001u;
}
void WSASendToMessage::clear_socket() {
  socket_ = GOOGLE_LONGLONG(0);
  clear_has_socket();
}
 ::google::protobuf::int64 WSASendToMessage::socket() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Server.WSASendToMessage.socket)
  return socket_;
}
 void WSASendToMessage::set_socket(::google::protobuf::int64 value) {
  set_has_socket();
  socket_ = value;
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Server.WSASendToMessage.socket)
}

// repeated bytes buffers = 2;
int WSASendToMessage::buffers_size() const {
  return buffers_.size();
}
void WSASendToMessage::clear_buffers() {
  buffers_.Clear();
}
 const ::std::string& WSASendToMessage::buffers(int index) const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Server.WSASendToMessage.buffers)
  return buffers_.Get(index);
}
 ::std::string* WSASendToMessage::mutable_buffers(int index) {
  // @@protoc_insertion_point(field_mutable:Hekate.Protobuf.Proto.Server.WSASendToMessage.buffers)
  return buffers_.Mutable(index);
}
 void WSASendToMessage::set_buffers(int index, const ::std::string& value) {
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Server.WSASendToMessage.buffers)
  buffers_.Mutable(index)->assign(value);
}
 void WSASendToMessage::set_buffers(int index, const char* value) {
  buffers_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:Hekate.Protobuf.Proto.Server.WSASendToMessage.buffers)
}
 void WSASendToMessage::set_buffers(int index, const void* value, size_t size) {
  buffers_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:Hekate.Protobuf.Proto.Server.WSASendToMessage.buffers)
}
 ::std::string* WSASendToMessage::add_buffers() {
  return buffers_.Add();
}
 void WSASendToMessage::add_buffers(const ::std::string& value) {
  buffers_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:Hekate.Protobuf.Proto.Server.WSASendToMessage.buffers)
}
 void WSASendToMessage::add_buffers(const char* value) {
  buffers_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:Hekate.Protobuf.Proto.Server.WSASendToMessage.buffers)
}
 void WSASendToMessage::add_buffers(const void* value, size_t size) {
  buffers_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:Hekate.Protobuf.Proto.Server.WSASendToMessage.buffers)
}
 const ::google::protobuf::RepeatedPtrField< ::std::string>&
WSASendToMessage::buffers() const {
  // @@protoc_insertion_point(field_list:Hekate.Protobuf.Proto.Server.WSASendToMessage.buffers)
  return buffers_;
}
 ::google::protobuf::RepeatedPtrField< ::std::string>*
WSASendToMessage::mutable_buffers() {
  // @@protoc_insertion_point(field_mutable_list:Hekate.Protobuf.Proto.Server.WSASendToMessage.buffers)
  return &buffers_;
}

// repeated int32 buffer_size = 3;
int WSASendToMessage::buffer_size_size() const {
  return buffer_size_.size();
}
void WSASendToMessage::clear_buffer_size() {
  buffer_size_.Clear();
}
 ::google::protobuf::int32 WSASendToMessage::buffer_size(int index) const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Server.WSASendToMessage.buffer_size)
  return buffer_size_.Get(index);
}
 void WSASendToMessage::set_buffer_size(int index, ::google::protobuf::int32 value) {
  buffer_size_.Set(index, value);
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Server.WSASendToMessage.buffer_size)
}
 void WSASendToMessage::add_buffer_size(::google::protobuf::int32 value) {
  buffer_size_.Add(value);
  // @@protoc_insertion_point(field_add:Hekate.Protobuf.Proto.Server.WSASendToMessage.buffer_size)
}
 const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
WSASendToMessage::buffer_size() const {
  // @@protoc_insertion_point(field_list:Hekate.Protobuf.Proto.Server.WSASendToMessage.buffer_size)
  return buffer_size_;
}
 ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
WSASendToMessage::mutable_buffer_size() {
  // @@protoc_insertion_point(field_mutable_list:Hekate.Protobuf.Proto.Server.WSASendToMessage.buffer_size)
  return &buffer_size_;
}

// required int32 count = 4;
bool WSASendToMessage::has_count() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
void WSASendToMessage::set_has_count() {
  _has_bits_[0] |= 0x00000008u;
}
void WSASendToMessage::clear_has_count() {
  _has_bits_[0] &= ~0x00000008u;
}
void WSASendToMessage::clear_count() {
  count_ = 0;
  clear_has_count();
}
 ::google::protobuf::int32 WSASendToMessage::count() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Server.WSASendToMessage.count)
  return count_;
}
 void WSASendToMessage::set_count(::google::protobuf::int32 value) {
  set_has_count();
  count_ = value;
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Server.WSASendToMessage.count)
}

// required int64 bytes_sent_address = 5;
bool WSASendToMessage::has_bytes_sent_address() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
void WSASendToMessage::set_has_bytes_sent_address() {
  _has_bits_[0] |= 0x00000010u;
}
void WSASendToMessage::clear_has_bytes_sent_address() {
  _has_bits_[0] &= ~0x00000010u;
}
void WSASendToMessage::clear_bytes_sent_address() {
  bytes_sent_address_ = GOOGLE_LONGLONG(0);
  clear_has_bytes_sent_address();
}
 ::google::protobuf::int64 WSASendToMessage::bytes_sent_address() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Server.WSASendToMessage.bytes_sent_address)
  return bytes_sent_address_;
}
 void WSASendToMessage::set_bytes_sent_address(::google::protobuf::int64 value) {
  set_has_bytes_sent_address();
  bytes_sent_address_ = value;
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Server.WSASendToMessage.bytes_sent_address)
}

// required int32 flags = 6;
bool WSASendToMessage::has_flags() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
void WSASendToMessage::set_has_flags() {
  _has_bits_[0] |= 0x00000020u;
}
void WSASendToMessage::clear_has_flags() {
  _has_bits_[0] &= ~0x00000020u;
}
void WSASendToMessage::clear_flags() {
  flags_ = 0;
  clear_has_flags();
}
 ::google::protobuf::int32 WSASendToMessage::flags() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Server.WSASendToMessage.flags)
  return flags_;
}
 void WSASendToMessage::set_flags(::google::protobuf::int32 value) {
  set_has_flags();
  flags_ = value;
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Server.WSASendToMessage.flags)
}

// required int64 to_address = 7;
bool WSASendToMessage::has_to_address() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
void WSASendToMessage::set_has_to_address() {
  _has_bits_[0] |= 0x00000040u;
}
void WSASendToMessage::clear_has_to_address() {
  _has_bits_[0] &= ~0x00000040u;
}
void WSASendToMessage::clear_to_address() {
  to_address_ = GOOGLE_LONGLONG(0);
  clear_has_to_address();
}
 ::google::protobuf::int64 WSASendToMessage::to_address() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Server.WSASendToMessage.to_address)
  return to_address_;
}
 void WSASendToMessage::set_to_address(::google::protobuf::int64 value) {
  set_has_to_address();
  to_address_ = value;
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Server.WSASendToMessage.to_address)
}

// required int32 to_length = 8;
bool WSASendToMessage::has_to_length() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
void WSASendToMessage::set_has_to_length() {
  _has_bits_[0] |= 0x00000080u;
}
void WSASendToMessage::clear_has_to_length() {
  _has_bits_[0] &= ~0x00000080u;
}
void WSASendToMessage::clear_to_length() {
  to_length_ = 0;
  clear_has_to_length();
}
 ::google::protobuf::int32 WSASendToMessage::to_length() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Server.WSASendToMessage.to_length)
  return to_length_;
}
 void WSASendToMessage::set_to_length(::google::protobuf::int32 value) {
  set_has_to_length();
  to_length_ = value;
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Server.WSASendToMessage.to_length)
}

// required int64 overlapped_address = 9;
bool WSASendToMessage::has_overlapped_address() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
void WSASendToMessage::set_has_overlapped_address() {
  _has_bits_[0] |= 0x00000100u;
}
void WSASendToMessage::clear_has_overlapped_address() {
  _has_bits_[0] &= ~0x00000100u;
}
void WSASendToMessage::clear_overlapped_address() {
  overlapped_address_ = GOOGLE_LONGLONG(0);
  clear_has_overlapped_address();
}
 ::google::protobuf::int64 WSASendToMessage::overlapped_address() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Server.WSASendToMessage.overlapped_address)
  return overlapped_address_;
}
 void WSASendToMessage::set_overlapped_address(::google::protobuf::int64 value) {
  set_has_overlapped_address();
  overlapped_address_ = value;
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Server.WSASendToMessage.overlapped_address)
}

// required int64 overlapped_routine_address = 10;
bool WSASendToMessage::has_overlapped_routine_address() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
void WSASendToMessage::set_has_overlapped_routine_address() {
  _has_bits_[0] |= 0x00000200u;
}
void WSASendToMessage::clear_has_overlapped_routine_address() {
  _has_bits_[0] &= ~0x00000200u;
}
void WSASendToMessage::clear_overlapped_routine_address() {
  overlapped_routine_address_ = GOOGLE_LONGLONG(0);
  clear_has_overlapped_routine_address();
}
 ::google::protobuf::int64 WSASendToMessage::overlapped_routine_address() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Server.WSASendToMessage.overlapped_routine_address)
  return overlapped_routine_address_;
}
 void WSASendToMessage::set_overlapped_routine_address(::google::protobuf::int64 value) {
  set_has_overlapped_routine_address();
  overlapped_routine_address_ = value;
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Server.WSASendToMessage.overlapped_routine_address)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

// ===================================================================

#ifndef _MSC_VER
const int RecvMessage::kSocketFieldNumber;
const int RecvMessage::kBufferFieldNumber;
const int RecvMessage::kLengthFieldNumber;
const int RecvMessage::kFlagsFieldNumber;
#endif  // !_MSC_VER

RecvMessage::RecvMessage()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:Hekate.Protobuf.Proto.Server.RecvMessage)
}

void RecvMessage::InitAsDefaultInstance() {
}

RecvMessage::RecvMessage(const RecvMessage& from)
  : ::google::protobuf::Message(),
    _internal_metadata_(NULL) {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:Hekate.Protobuf.Proto.Server.RecvMessage)
}

void RecvMessage::SharedCtor() {
  _cached_size_ = 0;
  socket_ = GOOGLE_LONGLONG(0);
  buffer_ = GOOGLE_LONGLONG(0);
  length_ = 0;
  flags_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

RecvMessage::~RecvMessage() {
  // @@protoc_insertion_point(destructor:Hekate.Protobuf.Proto.Server.RecvMessage)
  SharedDtor();
}

void RecvMessage::SharedDtor() {
  if (this != default_instance_) {
  }
}

void RecvMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* RecvMessage::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return RecvMessage_descriptor_;
}

const RecvMessage& RecvMessage::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_HekateServerProto_2eproto();
  return *default_instance_;
}

RecvMessage* RecvMessage::default_instance_ = NULL;

RecvMessage* RecvMessage::New(::google::protobuf::Arena* arena) const {
  RecvMessage* n = new RecvMessage;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void RecvMessage::Clear() {
#define ZR_HELPER_(f) reinterpret_cast<char*>(\
  &reinterpret_cast<RecvMessage*>(16)->f)

#define ZR_(first, last) do {\
  ::memset(&first, 0,\
           ZR_HELPER_(last) - ZR_HELPER_(first) + sizeof(last));\
} while (0)

  ZR_(socket_, flags_);

#undef ZR_HELPER_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  if (_internal_metadata_.have_unknown_fields()) {
    mutable_unknown_fields()->Clear();
  }
}

bool RecvMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:Hekate.Protobuf.Proto.Server.RecvMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required int64 socket = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &socket_)));
          set_has_socket();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_buffer;
        break;
      }

      // required int64 buffer = 2;
      case 2: {
        if (tag == 16) {
         parse_buffer:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &buffer_)));
          set_has_buffer();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_length;
        break;
      }

      // required int32 length = 3;
      case 3: {
        if (tag == 24) {
         parse_length:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &length_)));
          set_has_length();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(32)) goto parse_flags;
        break;
      }

      // required int32 flags = 4;
      case 4: {
        if (tag == 32) {
         parse_flags:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &flags_)));
          set_has_flags();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:Hekate.Protobuf.Proto.Server.RecvMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:Hekate.Protobuf.Proto.Server.RecvMessage)
  return false;
#undef DO_
}

void RecvMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:Hekate.Protobuf.Proto.Server.RecvMessage)
  // required int64 socket = 1;
  if (has_socket()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(1, this->socket(), output);
  }

  // required int64 buffer = 2;
  if (has_buffer()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(2, this->buffer(), output);
  }

  // required int32 length = 3;
  if (has_length()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->length(), output);
  }

  // required int32 flags = 4;
  if (has_flags()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->flags(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:Hekate.Protobuf.Proto.Server.RecvMessage)
}

::google::protobuf::uint8* RecvMessage::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:Hekate.Protobuf.Proto.Server.RecvMessage)
  // required int64 socket = 1;
  if (has_socket()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(1, this->socket(), target);
  }

  // required int64 buffer = 2;
  if (has_buffer()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(2, this->buffer(), target);
  }

  // required int32 length = 3;
  if (has_length()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->length(), target);
  }

  // required int32 flags = 4;
  if (has_flags()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(4, this->flags(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:Hekate.Protobuf.Proto.Server.RecvMessage)
  return target;
}

int RecvMessage::RequiredFieldsByteSizeFallback() const {
  int total_size = 0;

  if (has_socket()) {
    // required int64 socket = 1;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int64Size(
        this->socket());
  }

  if (has_buffer()) {
    // required int64 buffer = 2;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int64Size(
        this->buffer());
  }

  if (has_length()) {
    // required int32 length = 3;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int32Size(
        this->length());
  }

  if (has_flags()) {
    // required int32 flags = 4;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int32Size(
        this->flags());
  }

  return total_size;
}
int RecvMessage::ByteSize() const {
  int total_size = 0;

  if (((_has_bits_[0] & 0x0000000f) ^ 0x0000000f) == 0) {  // All required fields are present.
    // required int64 socket = 1;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int64Size(
        this->socket());

    // required int64 buffer = 2;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int64Size(
        this->buffer());

    // required int32 length = 3;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int32Size(
        this->length());

    // required int32 flags = 4;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int32Size(
        this->flags());

  } else {
    total_size += RequiredFieldsByteSizeFallback();
  }
  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void RecvMessage::MergeFrom(const ::google::protobuf::Message& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  const RecvMessage* source = 
      ::google::protobuf::internal::DynamicCastToGenerated<const RecvMessage>(
          &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void RecvMessage::MergeFrom(const RecvMessage& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_socket()) {
      set_socket(from.socket());
    }
    if (from.has_buffer()) {
      set_buffer(from.buffer());
    }
    if (from.has_length()) {
      set_length(from.length());
    }
    if (from.has_flags()) {
      set_flags(from.flags());
    }
  }
  if (from._internal_metadata_.have_unknown_fields()) {
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
}

void RecvMessage::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void RecvMessage::CopyFrom(const RecvMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RecvMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x0000000f) != 0x0000000f) return false;

  return true;
}

void RecvMessage::Swap(RecvMessage* other) {
  if (other == this) return;
  InternalSwap(other);
}
void RecvMessage::InternalSwap(RecvMessage* other) {
  std::swap(socket_, other->socket_);
  std::swap(buffer_, other->buffer_);
  std::swap(length_, other->length_);
  std::swap(flags_, other->flags_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata RecvMessage::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = RecvMessage_descriptor_;
  metadata.reflection = RecvMessage_reflection_;
  return metadata;
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// RecvMessage

// required int64 socket = 1;
bool RecvMessage::has_socket() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void RecvMessage::set_has_socket() {
  _has_bits_[0] |= 0x00000001u;
}
void RecvMessage::clear_has_socket() {
  _has_bits_[0] &= ~0x00000001u;
}
void RecvMessage::clear_socket() {
  socket_ = GOOGLE_LONGLONG(0);
  clear_has_socket();
}
 ::google::protobuf::int64 RecvMessage::socket() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Server.RecvMessage.socket)
  return socket_;
}
 void RecvMessage::set_socket(::google::protobuf::int64 value) {
  set_has_socket();
  socket_ = value;
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Server.RecvMessage.socket)
}

// required int64 buffer = 2;
bool RecvMessage::has_buffer() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void RecvMessage::set_has_buffer() {
  _has_bits_[0] |= 0x00000002u;
}
void RecvMessage::clear_has_buffer() {
  _has_bits_[0] &= ~0x00000002u;
}
void RecvMessage::clear_buffer() {
  buffer_ = GOOGLE_LONGLONG(0);
  clear_has_buffer();
}
 ::google::protobuf::int64 RecvMessage::buffer() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Server.RecvMessage.buffer)
  return buffer_;
}
 void RecvMessage::set_buffer(::google::protobuf::int64 value) {
  set_has_buffer();
  buffer_ = value;
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Server.RecvMessage.buffer)
}

// required int32 length = 3;
bool RecvMessage::has_length() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
void RecvMessage::set_has_length() {
  _has_bits_[0] |= 0x00000004u;
}
void RecvMessage::clear_has_length() {
  _has_bits_[0] &= ~0x00000004u;
}
void RecvMessage::clear_length() {
  length_ = 0;
  clear_has_length();
}
 ::google::protobuf::int32 RecvMessage::length() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Server.RecvMessage.length)
  return length_;
}
 void RecvMessage::set_length(::google::protobuf::int32 value) {
  set_has_length();
  length_ = value;
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Server.RecvMessage.length)
}

// required int32 flags = 4;
bool RecvMessage::has_flags() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
void RecvMessage::set_has_flags() {
  _has_bits_[0] |= 0x00000008u;
}
void RecvMessage::clear_has_flags() {
  _has_bits_[0] &= ~0x00000008u;
}
void RecvMessage::clear_flags() {
  flags_ = 0;
  clear_has_flags();
}
 ::google::protobuf::int32 RecvMessage::flags() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Server.RecvMessage.flags)
  return flags_;
}
 void RecvMessage::set_flags(::google::protobuf::int32 value) {
  set_has_flags();
  flags_ = value;
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Server.RecvMessage.flags)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

// ===================================================================

#ifndef _MSC_VER
const int RecvFromMessage::kSocketFieldNumber;
const int RecvFromMessage::kBufferFieldNumber;
const int RecvFromMessage::kLengthFieldNumber;
const int RecvFromMessage::kFlagsFieldNumber;
const int RecvFromMessage::kFromAddressFieldNumber;
const int RecvFromMessage::kFromLengthAddressFieldNumber;
#endif  // !_MSC_VER

RecvFromMessage::RecvFromMessage()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:Hekate.Protobuf.Proto.Server.RecvFromMessage)
}

void RecvFromMessage::InitAsDefaultInstance() {
}

RecvFromMessage::RecvFromMessage(const RecvFromMessage& from)
  : ::google::protobuf::Message(),
    _internal_metadata_(NULL) {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:Hekate.Protobuf.Proto.Server.RecvFromMessage)
}

void RecvFromMessage::SharedCtor() {
  _cached_size_ = 0;
  socket_ = GOOGLE_LONGLONG(0);
  buffer_ = GOOGLE_LONGLONG(0);
  length_ = 0;
  flags_ = 0;
  from_address_ = GOOGLE_LONGLONG(0);
  from_length_address_ = GOOGLE_LONGLONG(0);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

RecvFromMessage::~RecvFromMessage() {
  // @@protoc_insertion_point(destructor:Hekate.Protobuf.Proto.Server.RecvFromMessage)
  SharedDtor();
}

void RecvFromMessage::SharedDtor() {
  if (this != default_instance_) {
  }
}

void RecvFromMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* RecvFromMessage::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return RecvFromMessage_descriptor_;
}

const RecvFromMessage& RecvFromMessage::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_HekateServerProto_2eproto();
  return *default_instance_;
}

RecvFromMessage* RecvFromMessage::default_instance_ = NULL;

RecvFromMessage* RecvFromMessage::New(::google::protobuf::Arena* arena) const {
  RecvFromMessage* n = new RecvFromMessage;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void RecvFromMessage::Clear() {
#define ZR_HELPER_(f) reinterpret_cast<char*>(\
  &reinterpret_cast<RecvFromMessage*>(16)->f)

#define ZR_(first, last) do {\
  ::memset(&first, 0,\
           ZR_HELPER_(last) - ZR_HELPER_(first) + sizeof(last));\
} while (0)

  if (_has_bits_[0 / 32] & 63u) {
    ZR_(socket_, from_length_address_);
  }

#undef ZR_HELPER_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  if (_internal_metadata_.have_unknown_fields()) {
    mutable_unknown_fields()->Clear();
  }
}

bool RecvFromMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:Hekate.Protobuf.Proto.Server.RecvFromMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required int64 socket = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &socket_)));
          set_has_socket();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_buffer;
        break;
      }

      // required int64 buffer = 2;
      case 2: {
        if (tag == 16) {
         parse_buffer:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &buffer_)));
          set_has_buffer();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_length;
        break;
      }

      // required int32 length = 3;
      case 3: {
        if (tag == 24) {
         parse_length:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &length_)));
          set_has_length();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(32)) goto parse_flags;
        break;
      }

      // required int32 flags = 4;
      case 4: {
        if (tag == 32) {
         parse_flags:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &flags_)));
          set_has_flags();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(40)) goto parse_from_address;
        break;
      }

      // required int64 from_address = 5;
      case 5: {
        if (tag == 40) {
         parse_from_address:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &from_address_)));
          set_has_from_address();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(48)) goto parse_from_length_address;
        break;
      }

      // required int64 from_length_address = 6;
      case 6: {
        if (tag == 48) {
         parse_from_length_address:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &from_length_address_)));
          set_has_from_length_address();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:Hekate.Protobuf.Proto.Server.RecvFromMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:Hekate.Protobuf.Proto.Server.RecvFromMessage)
  return false;
#undef DO_
}

void RecvFromMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:Hekate.Protobuf.Proto.Server.RecvFromMessage)
  // required int64 socket = 1;
  if (has_socket()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(1, this->socket(), output);
  }

  // required int64 buffer = 2;
  if (has_buffer()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(2, this->buffer(), output);
  }

  // required int32 length = 3;
  if (has_length()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->length(), output);
  }

  // required int32 flags = 4;
  if (has_flags()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->flags(), output);
  }

  // required int64 from_address = 5;
  if (has_from_address()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(5, this->from_address(), output);
  }

  // required int64 from_length_address = 6;
  if (has_from_length_address()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(6, this->from_length_address(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:Hekate.Protobuf.Proto.Server.RecvFromMessage)
}

::google::protobuf::uint8* RecvFromMessage::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:Hekate.Protobuf.Proto.Server.RecvFromMessage)
  // required int64 socket = 1;
  if (has_socket()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(1, this->socket(), target);
  }

  // required int64 buffer = 2;
  if (has_buffer()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(2, this->buffer(), target);
  }

  // required int32 length = 3;
  if (has_length()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->length(), target);
  }

  // required int32 flags = 4;
  if (has_flags()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(4, this->flags(), target);
  }

  // required int64 from_address = 5;
  if (has_from_address()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(5, this->from_address(), target);
  }

  // required int64 from_length_address = 6;
  if (has_from_length_address()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(6, this->from_length_address(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:Hekate.Protobuf.Proto.Server.RecvFromMessage)
  return target;
}

int RecvFromMessage::RequiredFieldsByteSizeFallback() const {
  int total_size = 0;

  if (has_socket()) {
    // required int64 socket = 1;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int64Size(
        this->socket());
  }

  if (has_buffer()) {
    // required int64 buffer = 2;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int64Size(
        this->buffer());
  }

  if (has_length()) {
    // required int32 length = 3;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int32Size(
        this->length());
  }

  if (has_flags()) {
    // required int32 flags = 4;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int32Size(
        this->flags());
  }

  if (has_from_address()) {
    // required int64 from_address = 5;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int64Size(
        this->from_address());
  }

  if (has_from_length_address()) {
    // required int64 from_length_address = 6;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int64Size(
        this->from_length_address());
  }

  return total_size;
}
int RecvFromMessage::ByteSize() const {
  int total_size = 0;

  if (((_has_bits_[0] & 0x0000003f) ^ 0x0000003f) == 0) {  // All required fields are present.
    // required int64 socket = 1;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int64Size(
        this->socket());

    // required int64 buffer = 2;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int64Size(
        this->buffer());

    // required int32 length = 3;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int32Size(
        this->length());

    // required int32 flags = 4;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int32Size(
        this->flags());

    // required int64 from_address = 5;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int64Size(
        this->from_address());

    // required int64 from_length_address = 6;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int64Size(
        this->from_length_address());

  } else {
    total_size += RequiredFieldsByteSizeFallback();
  }
  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void RecvFromMessage::MergeFrom(const ::google::protobuf::Message& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  const RecvFromMessage* source = 
      ::google::protobuf::internal::DynamicCastToGenerated<const RecvFromMessage>(
          &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void RecvFromMessage::MergeFrom(const RecvFromMessage& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_socket()) {
      set_socket(from.socket());
    }
    if (from.has_buffer()) {
      set_buffer(from.buffer());
    }
    if (from.has_length()) {
      set_length(from.length());
    }
    if (from.has_flags()) {
      set_flags(from.flags());
    }
    if (from.has_from_address()) {
      set_from_address(from.from_address());
    }
    if (from.has_from_length_address()) {
      set_from_length_address(from.from_length_address());
    }
  }
  if (from._internal_metadata_.have_unknown_fields()) {
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
}

void RecvFromMessage::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void RecvFromMessage::CopyFrom(const RecvFromMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RecvFromMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x0000003f) != 0x0000003f) return false;

  return true;
}

void RecvFromMessage::Swap(RecvFromMessage* other) {
  if (other == this) return;
  InternalSwap(other);
}
void RecvFromMessage::InternalSwap(RecvFromMessage* other) {
  std::swap(socket_, other->socket_);
  std::swap(buffer_, other->buffer_);
  std::swap(length_, other->length_);
  std::swap(flags_, other->flags_);
  std::swap(from_address_, other->from_address_);
  std::swap(from_length_address_, other->from_length_address_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata RecvFromMessage::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = RecvFromMessage_descriptor_;
  metadata.reflection = RecvFromMessage_reflection_;
  return metadata;
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// RecvFromMessage

// required int64 socket = 1;
bool RecvFromMessage::has_socket() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void RecvFromMessage::set_has_socket() {
  _has_bits_[0] |= 0x00000001u;
}
void RecvFromMessage::clear_has_socket() {
  _has_bits_[0] &= ~0x00000001u;
}
void RecvFromMessage::clear_socket() {
  socket_ = GOOGLE_LONGLONG(0);
  clear_has_socket();
}
 ::google::protobuf::int64 RecvFromMessage::socket() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Server.RecvFromMessage.socket)
  return socket_;
}
 void RecvFromMessage::set_socket(::google::protobuf::int64 value) {
  set_has_socket();
  socket_ = value;
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Server.RecvFromMessage.socket)
}

// required int64 buffer = 2;
bool RecvFromMessage::has_buffer() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void RecvFromMessage::set_has_buffer() {
  _has_bits_[0] |= 0x00000002u;
}
void RecvFromMessage::clear_has_buffer() {
  _has_bits_[0] &= ~0x00000002u;
}
void RecvFromMessage::clear_buffer() {
  buffer_ = GOOGLE_LONGLONG(0);
  clear_has_buffer();
}
 ::google::protobuf::int64 RecvFromMessage::buffer() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Server.RecvFromMessage.buffer)
  return buffer_;
}
 void RecvFromMessage::set_buffer(::google::protobuf::int64 value) {
  set_has_buffer();
  buffer_ = value;
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Server.RecvFromMessage.buffer)
}

// required int32 length = 3;
bool RecvFromMessage::has_length() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
void RecvFromMessage::set_has_length() {
  _has_bits_[0] |= 0x00000004u;
}
void RecvFromMessage::clear_has_length() {
  _has_bits_[0] &= ~0x00000004u;
}
void RecvFromMessage::clear_length() {
  length_ = 0;
  clear_has_length();
}
 ::google::protobuf::int32 RecvFromMessage::length() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Server.RecvFromMessage.length)
  return length_;
}
 void RecvFromMessage::set_length(::google::protobuf::int32 value) {
  set_has_length();
  length_ = value;
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Server.RecvFromMessage.length)
}

// required int32 flags = 4;
bool RecvFromMessage::has_flags() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
void RecvFromMessage::set_has_flags() {
  _has_bits_[0] |= 0x00000008u;
}
void RecvFromMessage::clear_has_flags() {
  _has_bits_[0] &= ~0x00000008u;
}
void RecvFromMessage::clear_flags() {
  flags_ = 0;
  clear_has_flags();
}
 ::google::protobuf::int32 RecvFromMessage::flags() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Server.RecvFromMessage.flags)
  return flags_;
}
 void RecvFromMessage::set_flags(::google::protobuf::int32 value) {
  set_has_flags();
  flags_ = value;
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Server.RecvFromMessage.flags)
}

// required int64 from_address = 5;
bool RecvFromMessage::has_from_address() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
void RecvFromMessage::set_has_from_address() {
  _has_bits_[0] |= 0x00000010u;
}
void RecvFromMessage::clear_has_from_address() {
  _has_bits_[0] &= ~0x00000010u;
}
void RecvFromMessage::clear_from_address() {
  from_address_ = GOOGLE_LONGLONG(0);
  clear_has_from_address();
}
 ::google::protobuf::int64 RecvFromMessage::from_address() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Server.RecvFromMessage.from_address)
  return from_address_;
}
 void RecvFromMessage::set_from_address(::google::protobuf::int64 value) {
  set_has_from_address();
  from_address_ = value;
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Server.RecvFromMessage.from_address)
}

// required int64 from_length_address = 6;
bool RecvFromMessage::has_from_length_address() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
void RecvFromMessage::set_has_from_length_address() {
  _has_bits_[0] |= 0x00000020u;
}
void RecvFromMessage::clear_has_from_length_address() {
  _has_bits_[0] &= ~0x00000020u;
}
void RecvFromMessage::clear_from_length_address() {
  from_length_address_ = GOOGLE_LONGLONG(0);
  clear_has_from_length_address();
}
 ::google::protobuf::int64 RecvFromMessage::from_length_address() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Server.RecvFromMessage.from_length_address)
  return from_length_address_;
}
 void RecvFromMessage::set_from_length_address(::google::protobuf::int64 value) {
  set_has_from_length_address();
  from_length_address_ = value;
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Server.RecvFromMessage.from_length_address)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

// ===================================================================

#ifndef _MSC_VER
const int WSARecvMessage::kSocketFieldNumber;
const int WSARecvMessage::kBuffersFieldNumber;
const int WSARecvMessage::kBufferSizeFieldNumber;
const int WSARecvMessage::kCountFieldNumber;
const int WSARecvMessage::kBytesReceivedAddressFieldNumber;
const int WSARecvMessage::kFlagsAddressFieldNumber;
const int WSARecvMessage::kOverlappedAddressFieldNumber;
const int WSARecvMessage::kOverlappedRoutineAddressFieldNumber;
#endif  // !_MSC_VER

WSARecvMessage::WSARecvMessage()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:Hekate.Protobuf.Proto.Server.WSARecvMessage)
}

void WSARecvMessage::InitAsDefaultInstance() {
}

WSARecvMessage::WSARecvMessage(const WSARecvMessage& from)
  : ::google::protobuf::Message(),
    _internal_metadata_(NULL) {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:Hekate.Protobuf.Proto.Server.WSARecvMessage)
}

void WSARecvMessage::SharedCtor() {
  _cached_size_ = 0;
  socket_ = GOOGLE_LONGLONG(0);
  count_ = 0;
  bytes_received_address_ = GOOGLE_LONGLONG(0);
  flags_address_ = GOOGLE_LONGLONG(0);
  overlapped_address_ = GOOGLE_LONGLONG(0);
  overlapped_routine_address_ = GOOGLE_LONGLONG(0);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

WSARecvMessage::~WSARecvMessage() {
  // @@protoc_insertion_point(destructor:Hekate.Protobuf.Proto.Server.WSARecvMessage)
  SharedDtor();
}

void WSARecvMessage::SharedDtor() {
  if (this != default_instance_) {
  }
}

void WSARecvMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* WSARecvMessage::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return WSARecvMessage_descriptor_;
}

const WSARecvMessage& WSARecvMessage::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_HekateServerProto_2eproto();
  return *default_instance_;
}

WSARecvMessage* WSARecvMessage::default_instance_ = NULL;

WSARecvMessage* WSARecvMessage::New(::google::protobuf::Arena* arena) const {
  WSARecvMessage* n = new WSARecvMessage;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void WSARecvMessage::Clear() {
#define ZR_HELPER_(f) reinterpret_cast<char*>(\
  &reinterpret_cast<WSARecvMessage*>(16)->f)

#define ZR_(first, last) do {\
  ::memset(&first, 0,\
           ZR_HELPER_(last) - ZR_HELPER_(first) + sizeof(last));\
} while (0)

  if (_has_bits_[0 / 32] & 249u) {
    ZR_(bytes_received_address_, count_);
    socket_ = GOOGLE_LONGLONG(0);
  }

#undef ZR_HELPER_
#undef ZR_

  buffers_.Clear();
  buffer_size_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  if (_internal_metadata_.have_unknown_fields()) {
    mutable_unknown_fields()->Clear();
  }
}

bool WSARecvMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:Hekate.Protobuf.Proto.Server.WSARecvMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required int64 socket = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &socket_)));
          set_has_socket();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_buffers;
        break;
      }

      // repeated int64 buffers = 2;
      case 2: {
        if (tag == 16) {
         parse_buffers:
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 1, 16, input, this->mutable_buffers())));
        } else if (tag == 18) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, this->mutable_buffers())));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_buffers;
        if (input->ExpectTag(24)) goto parse_buffer_size;
        break;
      }

      // repeated int32 buffer_size = 3;
      case 3: {
        if (tag == 24) {
         parse_buffer_size:
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 1, 24, input, this->mutable_buffer_size())));
        } else if (tag == 26) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, this->mutable_buffer_size())));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_buffer_size;
        if (input->ExpectTag(32)) goto parse_count;
        break;
      }

      // required int32 count = 4;
      case 4: {
        if (tag == 32) {
         parse_count:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &count_)));
          set_has_count();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(40)) goto parse_bytes_received_address;
        break;
      }

      // required int64 bytes_received_address = 5;
      case 5: {
        if (tag == 40) {
         parse_bytes_received_address:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &bytes_received_address_)));
          set_has_bytes_received_address();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(48)) goto parse_flags_address;
        break;
      }

      // required int64 flags_address = 6;
      case 6: {
        if (tag == 48) {
         parse_flags_address:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &flags_address_)));
          set_has_flags_address();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(56)) goto parse_overlapped_address;
        break;
      }

      // required int64 overlapped_address = 7;
      case 7: {
        if (tag == 56) {
         parse_overlapped_address:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &overlapped_address_)));
          set_has_overlapped_address();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(64)) goto parse_overlapped_routine_address;
        break;
      }

      // required int64 overlapped_routine_address = 8;
      case 8: {
        if (tag == 64) {
         parse_overlapped_routine_address:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &overlapped_routine_address_)));
          set_has_overlapped_routine_address();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:Hekate.Protobuf.Proto.Server.WSARecvMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:Hekate.Protobuf.Proto.Server.WSARecvMessage)
  return false;
#undef DO_
}

void WSARecvMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:Hekate.Protobuf.Proto.Server.WSARecvMessage)
  // required int64 socket = 1;
  if (has_socket()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(1, this->socket(), output);
  }

  // repeated int64 buffers = 2;
  for (int i = 0; i < this->buffers_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(
      2, this->buffers(i), output);
  }

  // repeated int32 buffer_size = 3;
  for (int i = 0; i < this->buffer_size_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(
      3, this->buffer_size(i), output);
  }

  // required int32 count = 4;
  if (has_count()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->count(), output);
  }

  // required int64 bytes_received_address = 5;
  if (has_bytes_received_address()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(5, this->bytes_received_address(), output);
  }

  // required int64 flags_address = 6;
  if (has_flags_address()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(6, this->flags_address(), output);
  }

  // required int64 overlapped_address = 7;
  if (has_overlapped_address()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(7, this->overlapped_address(), output);
  }

  // required int64 overlapped_routine_address = 8;
  if (has_overlapped_routine_address()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(8, this->overlapped_routine_address(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:Hekate.Protobuf.Proto.Server.WSARecvMessage)
}

::google::protobuf::uint8* WSARecvMessage::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:Hekate.Protobuf.Proto.Server.WSARecvMessage)
  // required int64 socket = 1;
  if (has_socket()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(1, this->socket(), target);
  }

  // repeated int64 buffers = 2;
  for (int i = 0; i < this->buffers_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteInt64ToArray(2, this->buffers(i), target);
  }

  // repeated int32 buffer_size = 3;
  for (int i = 0; i < this->buffer_size_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteInt32ToArray(3, this->buffer_size(i), target);
  }

  // required int32 count = 4;
  if (has_count()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(4, this->count(), target);
  }

  // required int64 bytes_received_address = 5;
  if (has_bytes_received_address()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(5, this->bytes_received_address(), target);
  }

  // required int64 flags_address = 6;
  if (has_flags_address()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(6, this->flags_address(), target);
  }

  // required int64 overlapped_address = 7;
  if (has_overlapped_address()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(7, this->overlapped_address(), target);
  }

  // required int64 overlapped_routine_address = 8;
  if (has_overlapped_routine_address()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(8, this->overlapped_routine_address(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:Hekate.Protobuf.Proto.Server.WSARecvMessage)
  return target;
}

int WSARecvMessage::RequiredFieldsByteSizeFallback() const {
  int total_size = 0;

  if (has_socket()) {
    // required int64 socket = 1;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int64Size(
        this->socket());
  }

  if (has_count()) {
    // required int32 count = 4;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int32Size(
        this->count());
  }

  if (has_bytes_received_address()) {
    // required int64 bytes_received_address = 5;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int64Size(
        this->bytes_received_address());
  }

  if (has_flags_address()) {
    // required int64 flags_address = 6;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int64Size(
        this->flags_address());
  }

  if (has_overlapped_address()) {
    // required int64 overlapped_address = 7;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int64Size(
        this->overlapped_address());
  }

  if (has_overlapped_routine_address()) {
    // required int64 overlapped_routine_address = 8;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int64Size(
        this->overlapped_routine_address());
  }

  return total_size;
}
int WSARecvMessage::ByteSize() const {
  int total_size = 0;

  if (((_has_bits_[0] & 0x000000f9) ^ 0x000000f9) == 0) {  // All required fields are present.
    // required int64 socket = 1;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int64Size(
        this->socket());

    // required int32 count = 4;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int32Size(
        this->count());

    // required int64 bytes_received_address = 5;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int64Size(
        this->bytes_received_address());

    // required int64 flags_address = 6;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int64Size(
        this->flags_address());

    // required int64 overlapped_address = 7;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int64Size(
        this->overlapped_address());

    // required int64 overlapped_routine_address = 8;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int64Size(
        this->overlapped_routine_address());

  } else {
    total_size += RequiredFieldsByteSizeFallback();
  }
  // repeated int64 buffers = 2;
  {
    int data_size = 0;
    for (int i = 0; i < this->buffers_size(); i++) {
      data_size += ::google::protobuf::internal::WireFormatLite::
        Int64Size(this->buffers(i));
    }
    total_size += 1 * this->buffers_size() + data_size;
  }

  // repeated int32 buffer_size = 3;
  {
    int data_size = 0;
    for (int i = 0; i < this->buffer_size_size(); i++) {
      data_size += ::google::protobuf::internal::WireFormatLite::
        Int32Size(this->buffer_size(i));
    }
    total_size += 1 * this->buffer_size_size() + data_size;
  }

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void WSARecvMessage::MergeFrom(const ::google::protobuf::Message& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  const WSARecvMessage* source = 
      ::google::protobuf::internal::DynamicCastToGenerated<const WSARecvMessage>(
          &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void WSARecvMessage::MergeFrom(const WSARecvMessage& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  buffers_.MergeFrom(from.buffers_);
  buffer_size_.MergeFrom(from.buffer_size_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_socket()) {
      set_socket(from.socket());
    }
    if (from.has_count()) {
      set_count(from.count());
    }
    if (from.has_bytes_received_address()) {
      set_bytes_received_address(from.bytes_received_address());
    }
    if (from.has_flags_address()) {
      set_flags_address(from.flags_address());
    }
    if (from.has_overlapped_address()) {
      set_overlapped_address(from.overlapped_address());
    }
    if (from.has_overlapped_routine_address()) {
      set_overlapped_routine_address(from.overlapped_routine_address());
    }
  }
  if (from._internal_metadata_.have_unknown_fields()) {
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
}

void WSARecvMessage::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void WSARecvMessage::CopyFrom(const WSARecvMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool WSARecvMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x000000f9) != 0x000000f9) return false;

  return true;
}

void WSARecvMessage::Swap(WSARecvMessage* other) {
  if (other == this) return;
  InternalSwap(other);
}
void WSARecvMessage::InternalSwap(WSARecvMessage* other) {
  std::swap(socket_, other->socket_);
  buffers_.UnsafeArenaSwap(&other->buffers_);
  buffer_size_.UnsafeArenaSwap(&other->buffer_size_);
  std::swap(count_, other->count_);
  std::swap(bytes_received_address_, other->bytes_received_address_);
  std::swap(flags_address_, other->flags_address_);
  std::swap(overlapped_address_, other->overlapped_address_);
  std::swap(overlapped_routine_address_, other->overlapped_routine_address_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata WSARecvMessage::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = WSARecvMessage_descriptor_;
  metadata.reflection = WSARecvMessage_reflection_;
  return metadata;
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// WSARecvMessage

// required int64 socket = 1;
bool WSARecvMessage::has_socket() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void WSARecvMessage::set_has_socket() {
  _has_bits_[0] |= 0x00000001u;
}
void WSARecvMessage::clear_has_socket() {
  _has_bits_[0] &= ~0x00000001u;
}
void WSARecvMessage::clear_socket() {
  socket_ = GOOGLE_LONGLONG(0);
  clear_has_socket();
}
 ::google::protobuf::int64 WSARecvMessage::socket() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Server.WSARecvMessage.socket)
  return socket_;
}
 void WSARecvMessage::set_socket(::google::protobuf::int64 value) {
  set_has_socket();
  socket_ = value;
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Server.WSARecvMessage.socket)
}

// repeated int64 buffers = 2;
int WSARecvMessage::buffers_size() const {
  return buffers_.size();
}
void WSARecvMessage::clear_buffers() {
  buffers_.Clear();
}
 ::google::protobuf::int64 WSARecvMessage::buffers(int index) const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Server.WSARecvMessage.buffers)
  return buffers_.Get(index);
}
 void WSARecvMessage::set_buffers(int index, ::google::protobuf::int64 value) {
  buffers_.Set(index, value);
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Server.WSARecvMessage.buffers)
}
 void WSARecvMessage::add_buffers(::google::protobuf::int64 value) {
  buffers_.Add(value);
  // @@protoc_insertion_point(field_add:Hekate.Protobuf.Proto.Server.WSARecvMessage.buffers)
}
 const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
WSARecvMessage::buffers() const {
  // @@protoc_insertion_point(field_list:Hekate.Protobuf.Proto.Server.WSARecvMessage.buffers)
  return buffers_;
}
 ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
WSARecvMessage::mutable_buffers() {
  // @@protoc_insertion_point(field_mutable_list:Hekate.Protobuf.Proto.Server.WSARecvMessage.buffers)
  return &buffers_;
}

// repeated int32 buffer_size = 3;
int WSARecvMessage::buffer_size_size() const {
  return buffer_size_.size();
}
void WSARecvMessage::clear_buffer_size() {
  buffer_size_.Clear();
}
 ::google::protobuf::int32 WSARecvMessage::buffer_size(int index) const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Server.WSARecvMessage.buffer_size)
  return buffer_size_.Get(index);
}
 void WSARecvMessage::set_buffer_size(int index, ::google::protobuf::int32 value) {
  buffer_size_.Set(index, value);
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Server.WSARecvMessage.buffer_size)
}
 void WSARecvMessage::add_buffer_size(::google::protobuf::int32 value) {
  buffer_size_.Add(value);
  // @@protoc_insertion_point(field_add:Hekate.Protobuf.Proto.Server.WSARecvMessage.buffer_size)
}
 const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
WSARecvMessage::buffer_size() const {
  // @@protoc_insertion_point(field_list:Hekate.Protobuf.Proto.Server.WSARecvMessage.buffer_size)
  return buffer_size_;
}
 ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
WSARecvMessage::mutable_buffer_size() {
  // @@protoc_insertion_point(field_mutable_list:Hekate.Protobuf.Proto.Server.WSARecvMessage.buffer_size)
  return &buffer_size_;
}

// required int32 count = 4;
bool WSARecvMessage::has_count() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
void WSARecvMessage::set_has_count() {
  _has_bits_[0] |= 0x00000008u;
}
void WSARecvMessage::clear_has_count() {
  _has_bits_[0] &= ~0x00000008u;
}
void WSARecvMessage::clear_count() {
  count_ = 0;
  clear_has_count();
}
 ::google::protobuf::int32 WSARecvMessage::count() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Server.WSARecvMessage.count)
  return count_;
}
 void WSARecvMessage::set_count(::google::protobuf::int32 value) {
  set_has_count();
  count_ = value;
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Server.WSARecvMessage.count)
}

// required int64 bytes_received_address = 5;
bool WSARecvMessage::has_bytes_received_address() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
void WSARecvMessage::set_has_bytes_received_address() {
  _has_bits_[0] |= 0x00000010u;
}
void WSARecvMessage::clear_has_bytes_received_address() {
  _has_bits_[0] &= ~0x00000010u;
}
void WSARecvMessage::clear_bytes_received_address() {
  bytes_received_address_ = GOOGLE_LONGLONG(0);
  clear_has_bytes_received_address();
}
 ::google::protobuf::int64 WSARecvMessage::bytes_received_address() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Server.WSARecvMessage.bytes_received_address)
  return bytes_received_address_;
}
 void WSARecvMessage::set_bytes_received_address(::google::protobuf::int64 value) {
  set_has_bytes_received_address();
  bytes_received_address_ = value;
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Server.WSARecvMessage.bytes_received_address)
}

// required int64 flags_address = 6;
bool WSARecvMessage::has_flags_address() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
void WSARecvMessage::set_has_flags_address() {
  _has_bits_[0] |= 0x00000020u;
}
void WSARecvMessage::clear_has_flags_address() {
  _has_bits_[0] &= ~0x00000020u;
}
void WSARecvMessage::clear_flags_address() {
  flags_address_ = GOOGLE_LONGLONG(0);
  clear_has_flags_address();
}
 ::google::protobuf::int64 WSARecvMessage::flags_address() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Server.WSARecvMessage.flags_address)
  return flags_address_;
}
 void WSARecvMessage::set_flags_address(::google::protobuf::int64 value) {
  set_has_flags_address();
  flags_address_ = value;
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Server.WSARecvMessage.flags_address)
}

// required int64 overlapped_address = 7;
bool WSARecvMessage::has_overlapped_address() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
void WSARecvMessage::set_has_overlapped_address() {
  _has_bits_[0] |= 0x00000040u;
}
void WSARecvMessage::clear_has_overlapped_address() {
  _has_bits_[0] &= ~0x00000040u;
}
void WSARecvMessage::clear_overlapped_address() {
  overlapped_address_ = GOOGLE_LONGLONG(0);
  clear_has_overlapped_address();
}
 ::google::protobuf::int64 WSARecvMessage::overlapped_address() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Server.WSARecvMessage.overlapped_address)
  return overlapped_address_;
}
 void WSARecvMessage::set_overlapped_address(::google::protobuf::int64 value) {
  set_has_overlapped_address();
  overlapped_address_ = value;
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Server.WSARecvMessage.overlapped_address)
}

// required int64 overlapped_routine_address = 8;
bool WSARecvMessage::has_overlapped_routine_address() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
void WSARecvMessage::set_has_overlapped_routine_address() {
  _has_bits_[0] |= 0x00000080u;
}
void WSARecvMessage::clear_has_overlapped_routine_address() {
  _has_bits_[0] &= ~0x00000080u;
}
void WSARecvMessage::clear_overlapped_routine_address() {
  overlapped_routine_address_ = GOOGLE_LONGLONG(0);
  clear_has_overlapped_routine_address();
}
 ::google::protobuf::int64 WSARecvMessage::overlapped_routine_address() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Server.WSARecvMessage.overlapped_routine_address)
  return overlapped_routine_address_;
}
 void WSARecvMessage::set_overlapped_routine_address(::google::protobuf::int64 value) {
  set_has_overlapped_routine_address();
  overlapped_routine_address_ = value;
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Server.WSARecvMessage.overlapped_routine_address)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

// ===================================================================

#ifndef _MSC_VER
const int WSARecvFromMessage::kSocketFieldNumber;
const int WSARecvFromMessage::kBuffersFieldNumber;
const int WSARecvFromMessage::kBufferSizeFieldNumber;
const int WSARecvFromMessage::kCountFieldNumber;
const int WSARecvFromMessage::kBytesReceivedAddressFieldNumber;
const int WSARecvFromMessage::kFlagsAddressFieldNumber;
const int WSARecvFromMessage::kFromAddressFieldNumber;
const int WSARecvFromMessage::kFromLengthAddressFieldNumber;
const int WSARecvFromMessage::kOverlappedAddressFieldNumber;
const int WSARecvFromMessage::kOverlappedRoutineAddressFieldNumber;
#endif  // !_MSC_VER

WSARecvFromMessage::WSARecvFromMessage()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:Hekate.Protobuf.Proto.Server.WSARecvFromMessage)
}

void WSARecvFromMessage::InitAsDefaultInstance() {
}

WSARecvFromMessage::WSARecvFromMessage(const WSARecvFromMessage& from)
  : ::google::protobuf::Message(),
    _internal_metadata_(NULL) {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:Hekate.Protobuf.Proto.Server.WSARecvFromMessage)
}

void WSARecvFromMessage::SharedCtor() {
  _cached_size_ = 0;
  socket_ = GOOGLE_LONGLONG(0);
  count_ = 0;
  bytes_received_address_ = GOOGLE_LONGLONG(0);
  flags_address_ = GOOGLE_LONGLONG(0);
  from_address_ = GOOGLE_LONGLONG(0);
  from_length_address_ = GOOGLE_LONGLONG(0);
  overlapped_address_ = GOOGLE_LONGLONG(0);
  overlapped_routine_address_ = GOOGLE_LONGLONG(0);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

WSARecvFromMessage::~WSARecvFromMessage() {
  // @@protoc_insertion_point(destructor:Hekate.Protobuf.Proto.Server.WSARecvFromMessage)
  SharedDtor();
}

void WSARecvFromMessage::SharedDtor() {
  if (this != default_instance_) {
  }
}

void WSARecvFromMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* WSARecvFromMessage::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return WSARecvFromMessage_descriptor_;
}

const WSARecvFromMessage& WSARecvFromMessage::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_HekateServerProto_2eproto();
  return *default_instance_;
}

WSARecvFromMessage* WSARecvFromMessage::default_instance_ = NULL;

WSARecvFromMessage* WSARecvFromMessage::New(::google::protobuf::Arena* arena) const {
  WSARecvFromMessage* n = new WSARecvFromMessage;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void WSARecvFromMessage::Clear() {
#define ZR_HELPER_(f) reinterpret_cast<char*>(\
  &reinterpret_cast<WSARecvFromMessage*>(16)->f)

#define ZR_(first, last) do {\
  ::memset(&first, 0,\
           ZR_HELPER_(last) - ZR_HELPER_(first) + sizeof(last));\
} while (0)

  if (_has_bits_[0 / 32] & 249u) {
    ZR_(bytes_received_address_, from_length_address_);
    socket_ = GOOGLE_LONGLONG(0);
    count_ = 0;
  }
  ZR_(overlapped_address_, overlapped_routine_address_);

#undef ZR_HELPER_
#undef ZR_

  buffers_.Clear();
  buffer_size_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  if (_internal_metadata_.have_unknown_fields()) {
    mutable_unknown_fields()->Clear();
  }
}

bool WSARecvFromMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:Hekate.Protobuf.Proto.Server.WSARecvFromMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required int64 socket = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &socket_)));
          set_has_socket();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_buffers;
        break;
      }

      // repeated int64 buffers = 2;
      case 2: {
        if (tag == 16) {
         parse_buffers:
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 1, 16, input, this->mutable_buffers())));
        } else if (tag == 18) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, this->mutable_buffers())));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_buffers;
        if (input->ExpectTag(24)) goto parse_buffer_size;
        break;
      }

      // repeated int32 buffer_size = 3;
      case 3: {
        if (tag == 24) {
         parse_buffer_size:
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 1, 24, input, this->mutable_buffer_size())));
        } else if (tag == 26) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, this->mutable_buffer_size())));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_buffer_size;
        if (input->ExpectTag(32)) goto parse_count;
        break;
      }

      // required int32 count = 4;
      case 4: {
        if (tag == 32) {
         parse_count:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &count_)));
          set_has_count();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(40)) goto parse_bytes_received_address;
        break;
      }

      // required int64 bytes_received_address = 5;
      case 5: {
        if (tag == 40) {
         parse_bytes_received_address:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &bytes_received_address_)));
          set_has_bytes_received_address();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(48)) goto parse_flags_address;
        break;
      }

      // required int64 flags_address = 6;
      case 6: {
        if (tag == 48) {
         parse_flags_address:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &flags_address_)));
          set_has_flags_address();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(56)) goto parse_from_address;
        break;
      }

      // required int64 from_address = 7;
      case 7: {
        if (tag == 56) {
         parse_from_address:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &from_address_)));
          set_has_from_address();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(64)) goto parse_from_length_address;
        break;
      }

      // required int64 from_length_address = 8;
      case 8: {
        if (tag == 64) {
         parse_from_length_address:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &from_length_address_)));
          set_has_from_length_address();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(72)) goto parse_overlapped_address;
        break;
      }

      // required int64 overlapped_address = 9;
      case 9: {
        if (tag == 72) {
         parse_overlapped_address:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &overlapped_address_)));
          set_has_overlapped_address();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(80)) goto parse_overlapped_routine_address;
        break;
      }

      // required int64 overlapped_routine_address = 10;
      case 10: {
        if (tag == 80) {
         parse_overlapped_routine_address:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &overlapped_routine_address_)));
          set_has_overlapped_routine_address();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:Hekate.Protobuf.Proto.Server.WSARecvFromMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:Hekate.Protobuf.Proto.Server.WSARecvFromMessage)
  return false;
#undef DO_
}

void WSARecvFromMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:Hekate.Protobuf.Proto.Server.WSARecvFromMessage)
  // required int64 socket = 1;
  if (has_socket()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(1, this->socket(), output);
  }

  // repeated int64 buffers = 2;
  for (int i = 0; i < this->buffers_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(
      2, this->buffers(i), output);
  }

  // repeated int32 buffer_size = 3;
  for (int i = 0; i < this->buffer_size_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(
      3, this->buffer_size(i), output);
  }

  // required int32 count = 4;
  if (has_count()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->count(), output);
  }

  // required int64 bytes_received_address = 5;
  if (has_bytes_received_address()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(5, this->bytes_received_address(), output);
  }

  // required int64 flags_address = 6;
  if (has_flags_address()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(6, this->flags_address(), output);
  }

  // required int64 from_address = 7;
  if (has_from_address()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(7, this->from_address(), output);
  }

  // required int64 from_length_address = 8;
  if (has_from_length_address()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(8, this->from_length_address(), output);
  }

  // required int64 overlapped_address = 9;
  if (has_overlapped_address()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(9, this->overlapped_address(), output);
  }

  // required int64 overlapped_routine_address = 10;
  if (has_overlapped_routine_address()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(10, this->overlapped_routine_address(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:Hekate.Protobuf.Proto.Server.WSARecvFromMessage)
}

::google::protobuf::uint8* WSARecvFromMessage::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:Hekate.Protobuf.Proto.Server.WSARecvFromMessage)
  // required int64 socket = 1;
  if (has_socket()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(1, this->socket(), target);
  }

  // repeated int64 buffers = 2;
  for (int i = 0; i < this->buffers_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteInt64ToArray(2, this->buffers(i), target);
  }

  // repeated int32 buffer_size = 3;
  for (int i = 0; i < this->buffer_size_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteInt32ToArray(3, this->buffer_size(i), target);
  }

  // required int32 count = 4;
  if (has_count()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(4, this->count(), target);
  }

  // required int64 bytes_received_address = 5;
  if (has_bytes_received_address()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(5, this->bytes_received_address(), target);
  }

  // required int64 flags_address = 6;
  if (has_flags_address()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(6, this->flags_address(), target);
  }

  // required int64 from_address = 7;
  if (has_from_address()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(7, this->from_address(), target);
  }

  // required int64 from_length_address = 8;
  if (has_from_length_address()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(8, this->from_length_address(), target);
  }

  // required int64 overlapped_address = 9;
  if (has_overlapped_address()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(9, this->overlapped_address(), target);
  }

  // required int64 overlapped_routine_address = 10;
  if (has_overlapped_routine_address()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(10, this->overlapped_routine_address(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:Hekate.Protobuf.Proto.Server.WSARecvFromMessage)
  return target;
}

int WSARecvFromMessage::RequiredFieldsByteSizeFallback() const {
  int total_size = 0;

  if (has_socket()) {
    // required int64 socket = 1;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int64Size(
        this->socket());
  }

  if (has_count()) {
    // required int32 count = 4;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int32Size(
        this->count());
  }

  if (has_bytes_received_address()) {
    // required int64 bytes_received_address = 5;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int64Size(
        this->bytes_received_address());
  }

  if (has_flags_address()) {
    // required int64 flags_address = 6;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int64Size(
        this->flags_address());
  }

  if (has_from_address()) {
    // required int64 from_address = 7;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int64Size(
        this->from_address());
  }

  if (has_from_length_address()) {
    // required int64 from_length_address = 8;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int64Size(
        this->from_length_address());
  }

  if (has_overlapped_address()) {
    // required int64 overlapped_address = 9;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int64Size(
        this->overlapped_address());
  }

  if (has_overlapped_routine_address()) {
    // required int64 overlapped_routine_address = 10;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int64Size(
        this->overlapped_routine_address());
  }

  return total_size;
}
int WSARecvFromMessage::ByteSize() const {
  int total_size = 0;

  if (((_has_bits_[0] & 0x000003f9) ^ 0x000003f9) == 0) {  // All required fields are present.
    // required int64 socket = 1;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int64Size(
        this->socket());

    // required int32 count = 4;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int32Size(
        this->count());

    // required int64 bytes_received_address = 5;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int64Size(
        this->bytes_received_address());

    // required int64 flags_address = 6;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int64Size(
        this->flags_address());

    // required int64 from_address = 7;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int64Size(
        this->from_address());

    // required int64 from_length_address = 8;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int64Size(
        this->from_length_address());

    // required int64 overlapped_address = 9;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int64Size(
        this->overlapped_address());

    // required int64 overlapped_routine_address = 10;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int64Size(
        this->overlapped_routine_address());

  } else {
    total_size += RequiredFieldsByteSizeFallback();
  }
  // repeated int64 buffers = 2;
  {
    int data_size = 0;
    for (int i = 0; i < this->buffers_size(); i++) {
      data_size += ::google::protobuf::internal::WireFormatLite::
        Int64Size(this->buffers(i));
    }
    total_size += 1 * this->buffers_size() + data_size;
  }

  // repeated int32 buffer_size = 3;
  {
    int data_size = 0;
    for (int i = 0; i < this->buffer_size_size(); i++) {
      data_size += ::google::protobuf::internal::WireFormatLite::
        Int32Size(this->buffer_size(i));
    }
    total_size += 1 * this->buffer_size_size() + data_size;
  }

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void WSARecvFromMessage::MergeFrom(const ::google::protobuf::Message& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  const WSARecvFromMessage* source = 
      ::google::protobuf::internal::DynamicCastToGenerated<const WSARecvFromMessage>(
          &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void WSARecvFromMessage::MergeFrom(const WSARecvFromMessage& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  buffers_.MergeFrom(from.buffers_);
  buffer_size_.MergeFrom(from.buffer_size_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_socket()) {
      set_socket(from.socket());
    }
    if (from.has_count()) {
      set_count(from.count());
    }
    if (from.has_bytes_received_address()) {
      set_bytes_received_address(from.bytes_received_address());
    }
    if (from.has_flags_address()) {
      set_flags_address(from.flags_address());
    }
    if (from.has_from_address()) {
      set_from_address(from.from_address());
    }
    if (from.has_from_length_address()) {
      set_from_length_address(from.from_length_address());
    }
  }
  if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
    if (from.has_overlapped_address()) {
      set_overlapped_address(from.overlapped_address());
    }
    if (from.has_overlapped_routine_address()) {
      set_overlapped_routine_address(from.overlapped_routine_address());
    }
  }
  if (from._internal_metadata_.have_unknown_fields()) {
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
}

void WSARecvFromMessage::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void WSARecvFromMessage::CopyFrom(const WSARecvFromMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool WSARecvFromMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x000003f9) != 0x000003f9) return false;

  return true;
}

void WSARecvFromMessage::Swap(WSARecvFromMessage* other) {
  if (other == this) return;
  InternalSwap(other);
}
void WSARecvFromMessage::InternalSwap(WSARecvFromMessage* other) {
  std::swap(socket_, other->socket_);
  buffers_.UnsafeArenaSwap(&other->buffers_);
  buffer_size_.UnsafeArenaSwap(&other->buffer_size_);
  std::swap(count_, other->count_);
  std::swap(bytes_received_address_, other->bytes_received_address_);
  std::swap(flags_address_, other->flags_address_);
  std::swap(from_address_, other->from_address_);
  std::swap(from_length_address_, other->from_length_address_);
  std::swap(overlapped_address_, other->overlapped_address_);
  std::swap(overlapped_routine_address_, other->overlapped_routine_address_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata WSARecvFromMessage::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = WSARecvFromMessage_descriptor_;
  metadata.reflection = WSARecvFromMessage_reflection_;
  return metadata;
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// WSARecvFromMessage

// required int64 socket = 1;
bool WSARecvFromMessage::has_socket() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void WSARecvFromMessage::set_has_socket() {
  _has_bits_[0] |= 0x00000001u;
}
void WSARecvFromMessage::clear_has_socket() {
  _has_bits_[0] &= ~0x00000001u;
}
void WSARecvFromMessage::clear_socket() {
  socket_ = GOOGLE_LONGLONG(0);
  clear_has_socket();
}
 ::google::protobuf::int64 WSARecvFromMessage::socket() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Server.WSARecvFromMessage.socket)
  return socket_;
}
 void WSARecvFromMessage::set_socket(::google::protobuf::int64 value) {
  set_has_socket();
  socket_ = value;
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Server.WSARecvFromMessage.socket)
}

// repeated int64 buffers = 2;
int WSARecvFromMessage::buffers_size() const {
  return buffers_.size();
}
void WSARecvFromMessage::clear_buffers() {
  buffers_.Clear();
}
 ::google::protobuf::int64 WSARecvFromMessage::buffers(int index) const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Server.WSARecvFromMessage.buffers)
  return buffers_.Get(index);
}
 void WSARecvFromMessage::set_buffers(int index, ::google::protobuf::int64 value) {
  buffers_.Set(index, value);
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Server.WSARecvFromMessage.buffers)
}
 void WSARecvFromMessage::add_buffers(::google::protobuf::int64 value) {
  buffers_.Add(value);
  // @@protoc_insertion_point(field_add:Hekate.Protobuf.Proto.Server.WSARecvFromMessage.buffers)
}
 const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
WSARecvFromMessage::buffers() const {
  // @@protoc_insertion_point(field_list:Hekate.Protobuf.Proto.Server.WSARecvFromMessage.buffers)
  return buffers_;
}
 ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
WSARecvFromMessage::mutable_buffers() {
  // @@protoc_insertion_point(field_mutable_list:Hekate.Protobuf.Proto.Server.WSARecvFromMessage.buffers)
  return &buffers_;
}

// repeated int32 buffer_size = 3;
int WSARecvFromMessage::buffer_size_size() const {
  return buffer_size_.size();
}
void WSARecvFromMessage::clear_buffer_size() {
  buffer_size_.Clear();
}
 ::google::protobuf::int32 WSARecvFromMessage::buffer_size(int index) const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Server.WSARecvFromMessage.buffer_size)
  return buffer_size_.Get(index);
}
 void WSARecvFromMessage::set_buffer_size(int index, ::google::protobuf::int32 value) {
  buffer_size_.Set(index, value);
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Server.WSARecvFromMessage.buffer_size)
}
 void WSARecvFromMessage::add_buffer_size(::google::protobuf::int32 value) {
  buffer_size_.Add(value);
  // @@protoc_insertion_point(field_add:Hekate.Protobuf.Proto.Server.WSARecvFromMessage.buffer_size)
}
 const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
WSARecvFromMessage::buffer_size() const {
  // @@protoc_insertion_point(field_list:Hekate.Protobuf.Proto.Server.WSARecvFromMessage.buffer_size)
  return buffer_size_;
}
 ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
WSARecvFromMessage::mutable_buffer_size() {
  // @@protoc_insertion_point(field_mutable_list:Hekate.Protobuf.Proto.Server.WSARecvFromMessage.buffer_size)
  return &buffer_size_;
}

// required int32 count = 4;
bool WSARecvFromMessage::has_count() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
void WSARecvFromMessage::set_has_count() {
  _has_bits_[0] |= 0x00000008u;
}
void WSARecvFromMessage::clear_has_count() {
  _has_bits_[0] &= ~0x00000008u;
}
void WSARecvFromMessage::clear_count() {
  count_ = 0;
  clear_has_count();
}
 ::google::protobuf::int32 WSARecvFromMessage::count() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Server.WSARecvFromMessage.count)
  return count_;
}
 void WSARecvFromMessage::set_count(::google::protobuf::int32 value) {
  set_has_count();
  count_ = value;
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Server.WSARecvFromMessage.count)
}

// required int64 bytes_received_address = 5;
bool WSARecvFromMessage::has_bytes_received_address() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
void WSARecvFromMessage::set_has_bytes_received_address() {
  _has_bits_[0] |= 0x00000010u;
}
void WSARecvFromMessage::clear_has_bytes_received_address() {
  _has_bits_[0] &= ~0x00000010u;
}
void WSARecvFromMessage::clear_bytes_received_address() {
  bytes_received_address_ = GOOGLE_LONGLONG(0);
  clear_has_bytes_received_address();
}
 ::google::protobuf::int64 WSARecvFromMessage::bytes_received_address() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Server.WSARecvFromMessage.bytes_received_address)
  return bytes_received_address_;
}
 void WSARecvFromMessage::set_bytes_received_address(::google::protobuf::int64 value) {
  set_has_bytes_received_address();
  bytes_received_address_ = value;
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Server.WSARecvFromMessage.bytes_received_address)
}

// required int64 flags_address = 6;
bool WSARecvFromMessage::has_flags_address() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
void WSARecvFromMessage::set_has_flags_address() {
  _has_bits_[0] |= 0x00000020u;
}
void WSARecvFromMessage::clear_has_flags_address() {
  _has_bits_[0] &= ~0x00000020u;
}
void WSARecvFromMessage::clear_flags_address() {
  flags_address_ = GOOGLE_LONGLONG(0);
  clear_has_flags_address();
}
 ::google::protobuf::int64 WSARecvFromMessage::flags_address() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Server.WSARecvFromMessage.flags_address)
  return flags_address_;
}
 void WSARecvFromMessage::set_flags_address(::google::protobuf::int64 value) {
  set_has_flags_address();
  flags_address_ = value;
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Server.WSARecvFromMessage.flags_address)
}

// required int64 from_address = 7;
bool WSARecvFromMessage::has_from_address() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
void WSARecvFromMessage::set_has_from_address() {
  _has_bits_[0] |= 0x00000040u;
}
void WSARecvFromMessage::clear_has_from_address() {
  _has_bits_[0] &= ~0x00000040u;
}
void WSARecvFromMessage::clear_from_address() {
  from_address_ = GOOGLE_LONGLONG(0);
  clear_has_from_address();
}
 ::google::protobuf::int64 WSARecvFromMessage::from_address() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Server.WSARecvFromMessage.from_address)
  return from_address_;
}
 void WSARecvFromMessage::set_from_address(::google::protobuf::int64 value) {
  set_has_from_address();
  from_address_ = value;
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Server.WSARecvFromMessage.from_address)
}

// required int64 from_length_address = 8;
bool WSARecvFromMessage::has_from_length_address() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
void WSARecvFromMessage::set_has_from_length_address() {
  _has_bits_[0] |= 0x00000080u;
}
void WSARecvFromMessage::clear_has_from_length_address() {
  _has_bits_[0] &= ~0x00000080u;
}
void WSARecvFromMessage::clear_from_length_address() {
  from_length_address_ = GOOGLE_LONGLONG(0);
  clear_has_from_length_address();
}
 ::google::protobuf::int64 WSARecvFromMessage::from_length_address() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Server.WSARecvFromMessage.from_length_address)
  return from_length_address_;
}
 void WSARecvFromMessage::set_from_length_address(::google::protobuf::int64 value) {
  set_has_from_length_address();
  from_length_address_ = value;
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Server.WSARecvFromMessage.from_length_address)
}

// required int64 overlapped_address = 9;
bool WSARecvFromMessage::has_overlapped_address() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
void WSARecvFromMessage::set_has_overlapped_address() {
  _has_bits_[0] |= 0x00000100u;
}
void WSARecvFromMessage::clear_has_overlapped_address() {
  _has_bits_[0] &= ~0x00000100u;
}
void WSARecvFromMessage::clear_overlapped_address() {
  overlapped_address_ = GOOGLE_LONGLONG(0);
  clear_has_overlapped_address();
}
 ::google::protobuf::int64 WSARecvFromMessage::overlapped_address() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Server.WSARecvFromMessage.overlapped_address)
  return overlapped_address_;
}
 void WSARecvFromMessage::set_overlapped_address(::google::protobuf::int64 value) {
  set_has_overlapped_address();
  overlapped_address_ = value;
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Server.WSARecvFromMessage.overlapped_address)
}

// required int64 overlapped_routine_address = 10;
bool WSARecvFromMessage::has_overlapped_routine_address() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
void WSARecvFromMessage::set_has_overlapped_routine_address() {
  _has_bits_[0] |= 0x00000200u;
}
void WSARecvFromMessage::clear_has_overlapped_routine_address() {
  _has_bits_[0] &= ~0x00000200u;
}
void WSARecvFromMessage::clear_overlapped_routine_address() {
  overlapped_routine_address_ = GOOGLE_LONGLONG(0);
  clear_has_overlapped_routine_address();
}
 ::google::protobuf::int64 WSARecvFromMessage::overlapped_routine_address() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Server.WSARecvFromMessage.overlapped_routine_address)
  return overlapped_routine_address_;
}
 void WSARecvFromMessage::set_overlapped_routine_address(::google::protobuf::int64 value) {
  set_has_overlapped_routine_address();
  overlapped_routine_address_ = value;
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Server.WSARecvFromMessage.overlapped_routine_address)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

// ===================================================================

#ifndef _MSC_VER
const int HekateToClientMessage::kSendFieldNumber;
const int HekateToClientMessage::kSendtoFieldNumber;
const int HekateToClientMessage::kWsasendFieldNumber;
const int HekateToClientMessage::kWsasendtoFieldNumber;
const int HekateToClientMessage::kRecvFieldNumber;
const int HekateToClientMessage::kRecvfromFieldNumber;
const int HekateToClientMessage::kWsarecvFieldNumber;
const int HekateToClientMessage::kWsarecvfromFieldNumber;
const int HekateToClientMessage::kFilterMessageFieldNumber;
#endif  // !_MSC_VER

HekateToClientMessage::HekateToClientMessage()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:Hekate.Protobuf.Proto.Server.HekateToClientMessage)
}

void HekateToClientMessage::InitAsDefaultInstance() {
  send_ = const_cast< ::Hekate::Protobuf::Proto::Server::SendMessage_*>(&::Hekate::Protobuf::Proto::Server::SendMessage_::default_instance());
  sendto_ = const_cast< ::Hekate::Protobuf::Proto::Server::SendToMessage*>(&::Hekate::Protobuf::Proto::Server::SendToMessage::default_instance());
  wsasend_ = const_cast< ::Hekate::Protobuf::Proto::Server::WSASendMessage*>(&::Hekate::Protobuf::Proto::Server::WSASendMessage::default_instance());
  wsasendto_ = const_cast< ::Hekate::Protobuf::Proto::Server::WSASendToMessage*>(&::Hekate::Protobuf::Proto::Server::WSASendToMessage::default_instance());
  recv_ = const_cast< ::Hekate::Protobuf::Proto::Server::RecvMessage*>(&::Hekate::Protobuf::Proto::Server::RecvMessage::default_instance());
  recvfrom_ = const_cast< ::Hekate::Protobuf::Proto::Server::RecvFromMessage*>(&::Hekate::Protobuf::Proto::Server::RecvFromMessage::default_instance());
  wsarecv_ = const_cast< ::Hekate::Protobuf::Proto::Server::WSARecvMessage*>(&::Hekate::Protobuf::Proto::Server::WSARecvMessage::default_instance());
  wsarecvfrom_ = const_cast< ::Hekate::Protobuf::Proto::Server::WSARecvFromMessage*>(&::Hekate::Protobuf::Proto::Server::WSARecvFromMessage::default_instance());
  filter_message_ = const_cast< ::Hekate::Protobuf::Proto::Server::FilterHitMessage*>(&::Hekate::Protobuf::Proto::Server::FilterHitMessage::default_instance());
}

HekateToClientMessage::HekateToClientMessage(const HekateToClientMessage& from)
  : ::google::protobuf::Message(),
    _internal_metadata_(NULL) {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:Hekate.Protobuf.Proto.Server.HekateToClientMessage)
}

void HekateToClientMessage::SharedCtor() {
  _cached_size_ = 0;
  send_ = NULL;
  sendto_ = NULL;
  wsasend_ = NULL;
  wsasendto_ = NULL;
  recv_ = NULL;
  recvfrom_ = NULL;
  wsarecv_ = NULL;
  wsarecvfrom_ = NULL;
  filter_message_ = NULL;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

HekateToClientMessage::~HekateToClientMessage() {
  // @@protoc_insertion_point(destructor:Hekate.Protobuf.Proto.Server.HekateToClientMessage)
  SharedDtor();
}

void HekateToClientMessage::SharedDtor() {
  if (this != default_instance_) {
    delete send_;
    delete sendto_;
    delete wsasend_;
    delete wsasendto_;
    delete recv_;
    delete recvfrom_;
    delete wsarecv_;
    delete wsarecvfrom_;
    delete filter_message_;
  }
}

void HekateToClientMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* HekateToClientMessage::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return HekateToClientMessage_descriptor_;
}

const HekateToClientMessage& HekateToClientMessage::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_HekateServerProto_2eproto();
  return *default_instance_;
}

HekateToClientMessage* HekateToClientMessage::default_instance_ = NULL;

HekateToClientMessage* HekateToClientMessage::New(::google::protobuf::Arena* arena) const {
  HekateToClientMessage* n = new HekateToClientMessage;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void HekateToClientMessage::Clear() {
  if (_has_bits_[0 / 32] & 255u) {
    if (has_send()) {
      if (send_ != NULL) send_->::Hekate::Protobuf::Proto::Server::SendMessage_::Clear();
    }
    if (has_sendto()) {
      if (sendto_ != NULL) sendto_->::Hekate::Protobuf::Proto::Server::SendToMessage::Clear();
    }
    if (has_wsasend()) {
      if (wsasend_ != NULL) wsasend_->::Hekate::Protobuf::Proto::Server::WSASendMessage::Clear();
    }
    if (has_wsasendto()) {
      if (wsasendto_ != NULL) wsasendto_->::Hekate::Protobuf::Proto::Server::WSASendToMessage::Clear();
    }
    if (has_recv()) {
      if (recv_ != NULL) recv_->::Hekate::Protobuf::Proto::Server::RecvMessage::Clear();
    }
    if (has_recvfrom()) {
      if (recvfrom_ != NULL) recvfrom_->::Hekate::Protobuf::Proto::Server::RecvFromMessage::Clear();
    }
    if (has_wsarecv()) {
      if (wsarecv_ != NULL) wsarecv_->::Hekate::Protobuf::Proto::Server::WSARecvMessage::Clear();
    }
    if (has_wsarecvfrom()) {
      if (wsarecvfrom_ != NULL) wsarecvfrom_->::Hekate::Protobuf::Proto::Server::WSARecvFromMessage::Clear();
    }
  }
  if (has_filter_message()) {
    if (filter_message_ != NULL) filter_message_->::Hekate::Protobuf::Proto::Server::FilterHitMessage::Clear();
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  if (_internal_metadata_.have_unknown_fields()) {
    mutable_unknown_fields()->Clear();
  }
}

bool HekateToClientMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:Hekate.Protobuf.Proto.Server.HekateToClientMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .Hekate.Protobuf.Proto.Server.SendMessage_ send = 1;
      case 1: {
        if (tag == 10) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_send()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_sendto;
        break;
      }

      // optional .Hekate.Protobuf.Proto.Server.SendToMessage sendto = 2;
      case 2: {
        if (tag == 18) {
         parse_sendto:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_sendto()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_wsasend;
        break;
      }

      // optional .Hekate.Protobuf.Proto.Server.WSASendMessage wsasend = 3;
      case 3: {
        if (tag == 26) {
         parse_wsasend:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_wsasend()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(34)) goto parse_wsasendto;
        break;
      }

      // optional .Hekate.Protobuf.Proto.Server.WSASendToMessage wsasendto = 4;
      case 4: {
        if (tag == 34) {
         parse_wsasendto:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_wsasendto()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(42)) goto parse_recv;
        break;
      }

      // optional .Hekate.Protobuf.Proto.Server.RecvMessage recv = 5;
      case 5: {
        if (tag == 42) {
         parse_recv:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_recv()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(50)) goto parse_recvfrom;
        break;
      }

      // optional .Hekate.Protobuf.Proto.Server.RecvFromMessage recvfrom = 6;
      case 6: {
        if (tag == 50) {
         parse_recvfrom:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_recvfrom()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(58)) goto parse_wsarecv;
        break;
      }

      // optional .Hekate.Protobuf.Proto.Server.WSARecvMessage wsarecv = 7;
      case 7: {
        if (tag == 58) {
         parse_wsarecv:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_wsarecv()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(66)) goto parse_wsarecvfrom;
        break;
      }

      // optional .Hekate.Protobuf.Proto.Server.WSARecvFromMessage wsarecvfrom = 8;
      case 8: {
        if (tag == 66) {
         parse_wsarecvfrom:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_wsarecvfrom()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(74)) goto parse_filter_message;
        break;
      }

      // optional .Hekate.Protobuf.Proto.Server.FilterHitMessage filter_message = 9;
      case 9: {
        if (tag == 74) {
         parse_filter_message:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_filter_message()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:Hekate.Protobuf.Proto.Server.HekateToClientMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:Hekate.Protobuf.Proto.Server.HekateToClientMessage)
  return false;
#undef DO_
}

void HekateToClientMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:Hekate.Protobuf.Proto.Server.HekateToClientMessage)
  // optional .Hekate.Protobuf.Proto.Server.SendMessage_ send = 1;
  if (has_send()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, *this->send_, output);
  }

  // optional .Hekate.Protobuf.Proto.Server.SendToMessage sendto = 2;
  if (has_sendto()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      2, *this->sendto_, output);
  }

  // optional .Hekate.Protobuf.Proto.Server.WSASendMessage wsasend = 3;
  if (has_wsasend()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      3, *this->wsasend_, output);
  }

  // optional .Hekate.Protobuf.Proto.Server.WSASendToMessage wsasendto = 4;
  if (has_wsasendto()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      4, *this->wsasendto_, output);
  }

  // optional .Hekate.Protobuf.Proto.Server.RecvMessage recv = 5;
  if (has_recv()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      5, *this->recv_, output);
  }

  // optional .Hekate.Protobuf.Proto.Server.RecvFromMessage recvfrom = 6;
  if (has_recvfrom()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      6, *this->recvfrom_, output);
  }

  // optional .Hekate.Protobuf.Proto.Server.WSARecvMessage wsarecv = 7;
  if (has_wsarecv()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      7, *this->wsarecv_, output);
  }

  // optional .Hekate.Protobuf.Proto.Server.WSARecvFromMessage wsarecvfrom = 8;
  if (has_wsarecvfrom()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      8, *this->wsarecvfrom_, output);
  }

  // optional .Hekate.Protobuf.Proto.Server.FilterHitMessage filter_message = 9;
  if (has_filter_message()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      9, *this->filter_message_, output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:Hekate.Protobuf.Proto.Server.HekateToClientMessage)
}

::google::protobuf::uint8* HekateToClientMessage::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:Hekate.Protobuf.Proto.Server.HekateToClientMessage)
  // optional .Hekate.Protobuf.Proto.Server.SendMessage_ send = 1;
  if (has_send()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, *this->send_, target);
  }

  // optional .Hekate.Protobuf.Proto.Server.SendToMessage sendto = 2;
  if (has_sendto()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        2, *this->sendto_, target);
  }

  // optional .Hekate.Protobuf.Proto.Server.WSASendMessage wsasend = 3;
  if (has_wsasend()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        3, *this->wsasend_, target);
  }

  // optional .Hekate.Protobuf.Proto.Server.WSASendToMessage wsasendto = 4;
  if (has_wsasendto()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        4, *this->wsasendto_, target);
  }

  // optional .Hekate.Protobuf.Proto.Server.RecvMessage recv = 5;
  if (has_recv()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        5, *this->recv_, target);
  }

  // optional .Hekate.Protobuf.Proto.Server.RecvFromMessage recvfrom = 6;
  if (has_recvfrom()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        6, *this->recvfrom_, target);
  }

  // optional .Hekate.Protobuf.Proto.Server.WSARecvMessage wsarecv = 7;
  if (has_wsarecv()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        7, *this->wsarecv_, target);
  }

  // optional .Hekate.Protobuf.Proto.Server.WSARecvFromMessage wsarecvfrom = 8;
  if (has_wsarecvfrom()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        8, *this->wsarecvfrom_, target);
  }

  // optional .Hekate.Protobuf.Proto.Server.FilterHitMessage filter_message = 9;
  if (has_filter_message()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        9, *this->filter_message_, target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:Hekate.Protobuf.Proto.Server.HekateToClientMessage)
  return target;
}

int HekateToClientMessage::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & 255) {
    // optional .Hekate.Protobuf.Proto.Server.SendMessage_ send = 1;
    if (has_send()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *this->send_);
    }

    // optional .Hekate.Protobuf.Proto.Server.SendToMessage sendto = 2;
    if (has_sendto()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *this->sendto_);
    }

    // optional .Hekate.Protobuf.Proto.Server.WSASendMessage wsasend = 3;
    if (has_wsasend()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *this->wsasend_);
    }

    // optional .Hekate.Protobuf.Proto.Server.WSASendToMessage wsasendto = 4;
    if (has_wsasendto()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *this->wsasendto_);
    }

    // optional .Hekate.Protobuf.Proto.Server.RecvMessage recv = 5;
    if (has_recv()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *this->recv_);
    }

    // optional .Hekate.Protobuf.Proto.Server.RecvFromMessage recvfrom = 6;
    if (has_recvfrom()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *this->recvfrom_);
    }

    // optional .Hekate.Protobuf.Proto.Server.WSARecvMessage wsarecv = 7;
    if (has_wsarecv()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *this->wsarecv_);
    }

    // optional .Hekate.Protobuf.Proto.Server.WSARecvFromMessage wsarecvfrom = 8;
    if (has_wsarecvfrom()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *this->wsarecvfrom_);
    }

  }
  // optional .Hekate.Protobuf.Proto.Server.FilterHitMessage filter_message = 9;
  if (has_filter_message()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        *this->filter_message_);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void HekateToClientMessage::MergeFrom(const ::google::protobuf::Message& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  const HekateToClientMessage* source = 
      ::google::protobuf::internal::DynamicCastToGenerated<const HekateToClientMessage>(
          &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void HekateToClientMessage::MergeFrom(const HekateToClientMessage& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_send()) {
      mutable_send()->::Hekate::Protobuf::Proto::Server::SendMessage_::MergeFrom(from.send());
    }
    if (from.has_sendto()) {
      mutable_sendto()->::Hekate::Protobuf::Proto::Server::SendToMessage::MergeFrom(from.sendto());
    }
    if (from.has_wsasend()) {
      mutable_wsasend()->::Hekate::Protobuf::Proto::Server::WSASendMessage::MergeFrom(from.wsasend());
    }
    if (from.has_wsasendto()) {
      mutable_wsasendto()->::Hekate::Protobuf::Proto::Server::WSASendToMessage::MergeFrom(from.wsasendto());
    }
    if (from.has_recv()) {
      mutable_recv()->::Hekate::Protobuf::Proto::Server::RecvMessage::MergeFrom(from.recv());
    }
    if (from.has_recvfrom()) {
      mutable_recvfrom()->::Hekate::Protobuf::Proto::Server::RecvFromMessage::MergeFrom(from.recvfrom());
    }
    if (from.has_wsarecv()) {
      mutable_wsarecv()->::Hekate::Protobuf::Proto::Server::WSARecvMessage::MergeFrom(from.wsarecv());
    }
    if (from.has_wsarecvfrom()) {
      mutable_wsarecvfrom()->::Hekate::Protobuf::Proto::Server::WSARecvFromMessage::MergeFrom(from.wsarecvfrom());
    }
  }
  if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
    if (from.has_filter_message()) {
      mutable_filter_message()->::Hekate::Protobuf::Proto::Server::FilterHitMessage::MergeFrom(from.filter_message());
    }
  }
  if (from._internal_metadata_.have_unknown_fields()) {
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
}

void HekateToClientMessage::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void HekateToClientMessage::CopyFrom(const HekateToClientMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool HekateToClientMessage::IsInitialized() const {

  if (has_send()) {
    if (!this->send_->IsInitialized()) return false;
  }
  if (has_sendto()) {
    if (!this->sendto_->IsInitialized()) return false;
  }
  if (has_wsasend()) {
    if (!this->wsasend_->IsInitialized()) return false;
  }
  if (has_wsasendto()) {
    if (!this->wsasendto_->IsInitialized()) return false;
  }
  if (has_recv()) {
    if (!this->recv_->IsInitialized()) return false;
  }
  if (has_recvfrom()) {
    if (!this->recvfrom_->IsInitialized()) return false;
  }
  if (has_wsarecv()) {
    if (!this->wsarecv_->IsInitialized()) return false;
  }
  if (has_wsarecvfrom()) {
    if (!this->wsarecvfrom_->IsInitialized()) return false;
  }
  if (has_filter_message()) {
    if (!this->filter_message_->IsInitialized()) return false;
  }
  return true;
}

void HekateToClientMessage::Swap(HekateToClientMessage* other) {
  if (other == this) return;
  InternalSwap(other);
}
void HekateToClientMessage::InternalSwap(HekateToClientMessage* other) {
  std::swap(send_, other->send_);
  std::swap(sendto_, other->sendto_);
  std::swap(wsasend_, other->wsasend_);
  std::swap(wsasendto_, other->wsasendto_);
  std::swap(recv_, other->recv_);
  std::swap(recvfrom_, other->recvfrom_);
  std::swap(wsarecv_, other->wsarecv_);
  std::swap(wsarecvfrom_, other->wsarecvfrom_);
  std::swap(filter_message_, other->filter_message_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata HekateToClientMessage::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = HekateToClientMessage_descriptor_;
  metadata.reflection = HekateToClientMessage_reflection_;
  return metadata;
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// HekateToClientMessage

// optional .Hekate.Protobuf.Proto.Server.SendMessage_ send = 1;
bool HekateToClientMessage::has_send() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void HekateToClientMessage::set_has_send() {
  _has_bits_[0] |= 0x00000001u;
}
void HekateToClientMessage::clear_has_send() {
  _has_bits_[0] &= ~0x00000001u;
}
void HekateToClientMessage::clear_send() {
  if (send_ != NULL) send_->::Hekate::Protobuf::Proto::Server::SendMessage_::Clear();
  clear_has_send();
}
 const ::Hekate::Protobuf::Proto::Server::SendMessage_& HekateToClientMessage::send() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Server.HekateToClientMessage.send)
  return send_ != NULL ? *send_ : *default_instance_->send_;
}
 ::Hekate::Protobuf::Proto::Server::SendMessage_* HekateToClientMessage::mutable_send() {
  set_has_send();
  if (send_ == NULL) {
    send_ = new ::Hekate::Protobuf::Proto::Server::SendMessage_;
  }
  // @@protoc_insertion_point(field_mutable:Hekate.Protobuf.Proto.Server.HekateToClientMessage.send)
  return send_;
}
 ::Hekate::Protobuf::Proto::Server::SendMessage_* HekateToClientMessage::release_send() {
  clear_has_send();
  ::Hekate::Protobuf::Proto::Server::SendMessage_* temp = send_;
  send_ = NULL;
  return temp;
}
 void HekateToClientMessage::set_allocated_send(::Hekate::Protobuf::Proto::Server::SendMessage_* send) {
  delete send_;
  send_ = send;
  if (send) {
    set_has_send();
  } else {
    clear_has_send();
  }
  // @@protoc_insertion_point(field_set_allocated:Hekate.Protobuf.Proto.Server.HekateToClientMessage.send)
}

// optional .Hekate.Protobuf.Proto.Server.SendToMessage sendto = 2;
bool HekateToClientMessage::has_sendto() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void HekateToClientMessage::set_has_sendto() {
  _has_bits_[0] |= 0x00000002u;
}
void HekateToClientMessage::clear_has_sendto() {
  _has_bits_[0] &= ~0x00000002u;
}
void HekateToClientMessage::clear_sendto() {
  if (sendto_ != NULL) sendto_->::Hekate::Protobuf::Proto::Server::SendToMessage::Clear();
  clear_has_sendto();
}
 const ::Hekate::Protobuf::Proto::Server::SendToMessage& HekateToClientMessage::sendto() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Server.HekateToClientMessage.sendto)
  return sendto_ != NULL ? *sendto_ : *default_instance_->sendto_;
}
 ::Hekate::Protobuf::Proto::Server::SendToMessage* HekateToClientMessage::mutable_sendto() {
  set_has_sendto();
  if (sendto_ == NULL) {
    sendto_ = new ::Hekate::Protobuf::Proto::Server::SendToMessage;
  }
  // @@protoc_insertion_point(field_mutable:Hekate.Protobuf.Proto.Server.HekateToClientMessage.sendto)
  return sendto_;
}
 ::Hekate::Protobuf::Proto::Server::SendToMessage* HekateToClientMessage::release_sendto() {
  clear_has_sendto();
  ::Hekate::Protobuf::Proto::Server::SendToMessage* temp = sendto_;
  sendto_ = NULL;
  return temp;
}
 void HekateToClientMessage::set_allocated_sendto(::Hekate::Protobuf::Proto::Server::SendToMessage* sendto) {
  delete sendto_;
  sendto_ = sendto;
  if (sendto) {
    set_has_sendto();
  } else {
    clear_has_sendto();
  }
  // @@protoc_insertion_point(field_set_allocated:Hekate.Protobuf.Proto.Server.HekateToClientMessage.sendto)
}

// optional .Hekate.Protobuf.Proto.Server.WSASendMessage wsasend = 3;
bool HekateToClientMessage::has_wsasend() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
void HekateToClientMessage::set_has_wsasend() {
  _has_bits_[0] |= 0x00000004u;
}
void HekateToClientMessage::clear_has_wsasend() {
  _has_bits_[0] &= ~0x00000004u;
}
void HekateToClientMessage::clear_wsasend() {
  if (wsasend_ != NULL) wsasend_->::Hekate::Protobuf::Proto::Server::WSASendMessage::Clear();
  clear_has_wsasend();
}
 const ::Hekate::Protobuf::Proto::Server::WSASendMessage& HekateToClientMessage::wsasend() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Server.HekateToClientMessage.wsasend)
  return wsasend_ != NULL ? *wsasend_ : *default_instance_->wsasend_;
}
 ::Hekate::Protobuf::Proto::Server::WSASendMessage* HekateToClientMessage::mutable_wsasend() {
  set_has_wsasend();
  if (wsasend_ == NULL) {
    wsasend_ = new ::Hekate::Protobuf::Proto::Server::WSASendMessage;
  }
  // @@protoc_insertion_point(field_mutable:Hekate.Protobuf.Proto.Server.HekateToClientMessage.wsasend)
  return wsasend_;
}
 ::Hekate::Protobuf::Proto::Server::WSASendMessage* HekateToClientMessage::release_wsasend() {
  clear_has_wsasend();
  ::Hekate::Protobuf::Proto::Server::WSASendMessage* temp = wsasend_;
  wsasend_ = NULL;
  return temp;
}
 void HekateToClientMessage::set_allocated_wsasend(::Hekate::Protobuf::Proto::Server::WSASendMessage* wsasend) {
  delete wsasend_;
  wsasend_ = wsasend;
  if (wsasend) {
    set_has_wsasend();
  } else {
    clear_has_wsasend();
  }
  // @@protoc_insertion_point(field_set_allocated:Hekate.Protobuf.Proto.Server.HekateToClientMessage.wsasend)
}

// optional .Hekate.Protobuf.Proto.Server.WSASendToMessage wsasendto = 4;
bool HekateToClientMessage::has_wsasendto() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
void HekateToClientMessage::set_has_wsasendto() {
  _has_bits_[0] |= 0x00000008u;
}
void HekateToClientMessage::clear_has_wsasendto() {
  _has_bits_[0] &= ~0x00000008u;
}
void HekateToClientMessage::clear_wsasendto() {
  if (wsasendto_ != NULL) wsasendto_->::Hekate::Protobuf::Proto::Server::WSASendToMessage::Clear();
  clear_has_wsasendto();
}
 const ::Hekate::Protobuf::Proto::Server::WSASendToMessage& HekateToClientMessage::wsasendto() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Server.HekateToClientMessage.wsasendto)
  return wsasendto_ != NULL ? *wsasendto_ : *default_instance_->wsasendto_;
}
 ::Hekate::Protobuf::Proto::Server::WSASendToMessage* HekateToClientMessage::mutable_wsasendto() {
  set_has_wsasendto();
  if (wsasendto_ == NULL) {
    wsasendto_ = new ::Hekate::Protobuf::Proto::Server::WSASendToMessage;
  }
  // @@protoc_insertion_point(field_mutable:Hekate.Protobuf.Proto.Server.HekateToClientMessage.wsasendto)
  return wsasendto_;
}
 ::Hekate::Protobuf::Proto::Server::WSASendToMessage* HekateToClientMessage::release_wsasendto() {
  clear_has_wsasendto();
  ::Hekate::Protobuf::Proto::Server::WSASendToMessage* temp = wsasendto_;
  wsasendto_ = NULL;
  return temp;
}
 void HekateToClientMessage::set_allocated_wsasendto(::Hekate::Protobuf::Proto::Server::WSASendToMessage* wsasendto) {
  delete wsasendto_;
  wsasendto_ = wsasendto;
  if (wsasendto) {
    set_has_wsasendto();
  } else {
    clear_has_wsasendto();
  }
  // @@protoc_insertion_point(field_set_allocated:Hekate.Protobuf.Proto.Server.HekateToClientMessage.wsasendto)
}

// optional .Hekate.Protobuf.Proto.Server.RecvMessage recv = 5;
bool HekateToClientMessage::has_recv() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
void HekateToClientMessage::set_has_recv() {
  _has_bits_[0] |= 0x00000010u;
}
void HekateToClientMessage::clear_has_recv() {
  _has_bits_[0] &= ~0x00000010u;
}
void HekateToClientMessage::clear_recv() {
  if (recv_ != NULL) recv_->::Hekate::Protobuf::Proto::Server::RecvMessage::Clear();
  clear_has_recv();
}
 const ::Hekate::Protobuf::Proto::Server::RecvMessage& HekateToClientMessage::recv() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Server.HekateToClientMessage.recv)
  return recv_ != NULL ? *recv_ : *default_instance_->recv_;
}
 ::Hekate::Protobuf::Proto::Server::RecvMessage* HekateToClientMessage::mutable_recv() {
  set_has_recv();
  if (recv_ == NULL) {
    recv_ = new ::Hekate::Protobuf::Proto::Server::RecvMessage;
  }
  // @@protoc_insertion_point(field_mutable:Hekate.Protobuf.Proto.Server.HekateToClientMessage.recv)
  return recv_;
}
 ::Hekate::Protobuf::Proto::Server::RecvMessage* HekateToClientMessage::release_recv() {
  clear_has_recv();
  ::Hekate::Protobuf::Proto::Server::RecvMessage* temp = recv_;
  recv_ = NULL;
  return temp;
}
 void HekateToClientMessage::set_allocated_recv(::Hekate::Protobuf::Proto::Server::RecvMessage* recv) {
  delete recv_;
  recv_ = recv;
  if (recv) {
    set_has_recv();
  } else {
    clear_has_recv();
  }
  // @@protoc_insertion_point(field_set_allocated:Hekate.Protobuf.Proto.Server.HekateToClientMessage.recv)
}

// optional .Hekate.Protobuf.Proto.Server.RecvFromMessage recvfrom = 6;
bool HekateToClientMessage::has_recvfrom() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
void HekateToClientMessage::set_has_recvfrom() {
  _has_bits_[0] |= 0x00000020u;
}
void HekateToClientMessage::clear_has_recvfrom() {
  _has_bits_[0] &= ~0x00000020u;
}
void HekateToClientMessage::clear_recvfrom() {
  if (recvfrom_ != NULL) recvfrom_->::Hekate::Protobuf::Proto::Server::RecvFromMessage::Clear();
  clear_has_recvfrom();
}
 const ::Hekate::Protobuf::Proto::Server::RecvFromMessage& HekateToClientMessage::recvfrom() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Server.HekateToClientMessage.recvfrom)
  return recvfrom_ != NULL ? *recvfrom_ : *default_instance_->recvfrom_;
}
 ::Hekate::Protobuf::Proto::Server::RecvFromMessage* HekateToClientMessage::mutable_recvfrom() {
  set_has_recvfrom();
  if (recvfrom_ == NULL) {
    recvfrom_ = new ::Hekate::Protobuf::Proto::Server::RecvFromMessage;
  }
  // @@protoc_insertion_point(field_mutable:Hekate.Protobuf.Proto.Server.HekateToClientMessage.recvfrom)
  return recvfrom_;
}
 ::Hekate::Protobuf::Proto::Server::RecvFromMessage* HekateToClientMessage::release_recvfrom() {
  clear_has_recvfrom();
  ::Hekate::Protobuf::Proto::Server::RecvFromMessage* temp = recvfrom_;
  recvfrom_ = NULL;
  return temp;
}
 void HekateToClientMessage::set_allocated_recvfrom(::Hekate::Protobuf::Proto::Server::RecvFromMessage* recvfrom) {
  delete recvfrom_;
  recvfrom_ = recvfrom;
  if (recvfrom) {
    set_has_recvfrom();
  } else {
    clear_has_recvfrom();
  }
  // @@protoc_insertion_point(field_set_allocated:Hekate.Protobuf.Proto.Server.HekateToClientMessage.recvfrom)
}

// optional .Hekate.Protobuf.Proto.Server.WSARecvMessage wsarecv = 7;
bool HekateToClientMessage::has_wsarecv() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
void HekateToClientMessage::set_has_wsarecv() {
  _has_bits_[0] |= 0x00000040u;
}
void HekateToClientMessage::clear_has_wsarecv() {
  _has_bits_[0] &= ~0x00000040u;
}
void HekateToClientMessage::clear_wsarecv() {
  if (wsarecv_ != NULL) wsarecv_->::Hekate::Protobuf::Proto::Server::WSARecvMessage::Clear();
  clear_has_wsarecv();
}
 const ::Hekate::Protobuf::Proto::Server::WSARecvMessage& HekateToClientMessage::wsarecv() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Server.HekateToClientMessage.wsarecv)
  return wsarecv_ != NULL ? *wsarecv_ : *default_instance_->wsarecv_;
}
 ::Hekate::Protobuf::Proto::Server::WSARecvMessage* HekateToClientMessage::mutable_wsarecv() {
  set_has_wsarecv();
  if (wsarecv_ == NULL) {
    wsarecv_ = new ::Hekate::Protobuf::Proto::Server::WSARecvMessage;
  }
  // @@protoc_insertion_point(field_mutable:Hekate.Protobuf.Proto.Server.HekateToClientMessage.wsarecv)
  return wsarecv_;
}
 ::Hekate::Protobuf::Proto::Server::WSARecvMessage* HekateToClientMessage::release_wsarecv() {
  clear_has_wsarecv();
  ::Hekate::Protobuf::Proto::Server::WSARecvMessage* temp = wsarecv_;
  wsarecv_ = NULL;
  return temp;
}
 void HekateToClientMessage::set_allocated_wsarecv(::Hekate::Protobuf::Proto::Server::WSARecvMessage* wsarecv) {
  delete wsarecv_;
  wsarecv_ = wsarecv;
  if (wsarecv) {
    set_has_wsarecv();
  } else {
    clear_has_wsarecv();
  }
  // @@protoc_insertion_point(field_set_allocated:Hekate.Protobuf.Proto.Server.HekateToClientMessage.wsarecv)
}

// optional .Hekate.Protobuf.Proto.Server.WSARecvFromMessage wsarecvfrom = 8;
bool HekateToClientMessage::has_wsarecvfrom() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
void HekateToClientMessage::set_has_wsarecvfrom() {
  _has_bits_[0] |= 0x00000080u;
}
void HekateToClientMessage::clear_has_wsarecvfrom() {
  _has_bits_[0] &= ~0x00000080u;
}
void HekateToClientMessage::clear_wsarecvfrom() {
  if (wsarecvfrom_ != NULL) wsarecvfrom_->::Hekate::Protobuf::Proto::Server::WSARecvFromMessage::Clear();
  clear_has_wsarecvfrom();
}
 const ::Hekate::Protobuf::Proto::Server::WSARecvFromMessage& HekateToClientMessage::wsarecvfrom() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Server.HekateToClientMessage.wsarecvfrom)
  return wsarecvfrom_ != NULL ? *wsarecvfrom_ : *default_instance_->wsarecvfrom_;
}
 ::Hekate::Protobuf::Proto::Server::WSARecvFromMessage* HekateToClientMessage::mutable_wsarecvfrom() {
  set_has_wsarecvfrom();
  if (wsarecvfrom_ == NULL) {
    wsarecvfrom_ = new ::Hekate::Protobuf::Proto::Server::WSARecvFromMessage;
  }
  // @@protoc_insertion_point(field_mutable:Hekate.Protobuf.Proto.Server.HekateToClientMessage.wsarecvfrom)
  return wsarecvfrom_;
}
 ::Hekate::Protobuf::Proto::Server::WSARecvFromMessage* HekateToClientMessage::release_wsarecvfrom() {
  clear_has_wsarecvfrom();
  ::Hekate::Protobuf::Proto::Server::WSARecvFromMessage* temp = wsarecvfrom_;
  wsarecvfrom_ = NULL;
  return temp;
}
 void HekateToClientMessage::set_allocated_wsarecvfrom(::Hekate::Protobuf::Proto::Server::WSARecvFromMessage* wsarecvfrom) {
  delete wsarecvfrom_;
  wsarecvfrom_ = wsarecvfrom;
  if (wsarecvfrom) {
    set_has_wsarecvfrom();
  } else {
    clear_has_wsarecvfrom();
  }
  // @@protoc_insertion_point(field_set_allocated:Hekate.Protobuf.Proto.Server.HekateToClientMessage.wsarecvfrom)
}

// optional .Hekate.Protobuf.Proto.Server.FilterHitMessage filter_message = 9;
bool HekateToClientMessage::has_filter_message() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
void HekateToClientMessage::set_has_filter_message() {
  _has_bits_[0] |= 0x00000100u;
}
void HekateToClientMessage::clear_has_filter_message() {
  _has_bits_[0] &= ~0x00000100u;
}
void HekateToClientMessage::clear_filter_message() {
  if (filter_message_ != NULL) filter_message_->::Hekate::Protobuf::Proto::Server::FilterHitMessage::Clear();
  clear_has_filter_message();
}
 const ::Hekate::Protobuf::Proto::Server::FilterHitMessage& HekateToClientMessage::filter_message() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Server.HekateToClientMessage.filter_message)
  return filter_message_ != NULL ? *filter_message_ : *default_instance_->filter_message_;
}
 ::Hekate::Protobuf::Proto::Server::FilterHitMessage* HekateToClientMessage::mutable_filter_message() {
  set_has_filter_message();
  if (filter_message_ == NULL) {
    filter_message_ = new ::Hekate::Protobuf::Proto::Server::FilterHitMessage;
  }
  // @@protoc_insertion_point(field_mutable:Hekate.Protobuf.Proto.Server.HekateToClientMessage.filter_message)
  return filter_message_;
}
 ::Hekate::Protobuf::Proto::Server::FilterHitMessage* HekateToClientMessage::release_filter_message() {
  clear_has_filter_message();
  ::Hekate::Protobuf::Proto::Server::FilterHitMessage* temp = filter_message_;
  filter_message_ = NULL;
  return temp;
}
 void HekateToClientMessage::set_allocated_filter_message(::Hekate::Protobuf::Proto::Server::FilterHitMessage* filter_message) {
  delete filter_message_;
  filter_message_ = filter_message;
  if (filter_message) {
    set_has_filter_message();
  } else {
    clear_has_filter_message();
  }
  // @@protoc_insertion_point(field_set_allocated:Hekate.Protobuf.Proto.Server.HekateToClientMessage.filter_message)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

// ===================================================================

#ifndef _MSC_VER
const int AcknowledgeMessage::kDebugResponseIdFieldNumber;
#endif  // !_MSC_VER

AcknowledgeMessage::AcknowledgeMessage()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:Hekate.Protobuf.Proto.Server.AcknowledgeMessage)
}

void AcknowledgeMessage::InitAsDefaultInstance() {
}

AcknowledgeMessage::AcknowledgeMessage(const AcknowledgeMessage& from)
  : ::google::protobuf::Message(),
    _internal_metadata_(NULL) {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:Hekate.Protobuf.Proto.Server.AcknowledgeMessage)
}

void AcknowledgeMessage::SharedCtor() {
  _cached_size_ = 0;
  debug_response_id_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

AcknowledgeMessage::~AcknowledgeMessage() {
  // @@protoc_insertion_point(destructor:Hekate.Protobuf.Proto.Server.AcknowledgeMessage)
  SharedDtor();
}

void AcknowledgeMessage::SharedDtor() {
  if (this != default_instance_) {
  }
}

void AcknowledgeMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* AcknowledgeMessage::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return AcknowledgeMessage_descriptor_;
}

const AcknowledgeMessage& AcknowledgeMessage::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_HekateServerProto_2eproto();
  return *default_instance_;
}

AcknowledgeMessage* AcknowledgeMessage::default_instance_ = NULL;

AcknowledgeMessage* AcknowledgeMessage::New(::google::protobuf::Arena* arena) const {
  AcknowledgeMessage* n = new AcknowledgeMessage;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void AcknowledgeMessage::Clear() {
  debug_response_id_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  if (_internal_metadata_.have_unknown_fields()) {
    mutable_unknown_fields()->Clear();
  }
}

bool AcknowledgeMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:Hekate.Protobuf.Proto.Server.AcknowledgeMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 debug_response_id = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &debug_response_id_)));
          set_has_debug_response_id();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:Hekate.Protobuf.Proto.Server.AcknowledgeMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:Hekate.Protobuf.Proto.Server.AcknowledgeMessage)
  return false;
#undef DO_
}

void AcknowledgeMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:Hekate.Protobuf.Proto.Server.AcknowledgeMessage)
  // optional int32 debug_response_id = 1;
  if (has_debug_response_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->debug_response_id(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:Hekate.Protobuf.Proto.Server.AcknowledgeMessage)
}

::google::protobuf::uint8* AcknowledgeMessage::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:Hekate.Protobuf.Proto.Server.AcknowledgeMessage)
  // optional int32 debug_response_id = 1;
  if (has_debug_response_id()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->debug_response_id(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:Hekate.Protobuf.Proto.Server.AcknowledgeMessage)
  return target;
}

int AcknowledgeMessage::ByteSize() const {
  int total_size = 0;

  // optional int32 debug_response_id = 1;
  if (has_debug_response_id()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int32Size(
        this->debug_response_id());
  }

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void AcknowledgeMessage::MergeFrom(const ::google::protobuf::Message& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  const AcknowledgeMessage* source = 
      ::google::protobuf::internal::DynamicCastToGenerated<const AcknowledgeMessage>(
          &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void AcknowledgeMessage::MergeFrom(const AcknowledgeMessage& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_debug_response_id()) {
      set_debug_response_id(from.debug_response_id());
    }
  }
  if (from._internal_metadata_.have_unknown_fields()) {
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
}

void AcknowledgeMessage::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void AcknowledgeMessage::CopyFrom(const AcknowledgeMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool AcknowledgeMessage::IsInitialized() const {

  return true;
}

void AcknowledgeMessage::Swap(AcknowledgeMessage* other) {
  if (other == this) return;
  InternalSwap(other);
}
void AcknowledgeMessage::InternalSwap(AcknowledgeMessage* other) {
  std::swap(debug_response_id_, other->debug_response_id_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata AcknowledgeMessage::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = AcknowledgeMessage_descriptor_;
  metadata.reflection = AcknowledgeMessage_reflection_;
  return metadata;
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// AcknowledgeMessage

// optional int32 debug_response_id = 1;
bool AcknowledgeMessage::has_debug_response_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void AcknowledgeMessage::set_has_debug_response_id() {
  _has_bits_[0] |= 0x00000001u;
}
void AcknowledgeMessage::clear_has_debug_response_id() {
  _has_bits_[0] &= ~0x00000001u;
}
void AcknowledgeMessage::clear_debug_response_id() {
  debug_response_id_ = 0;
  clear_has_debug_response_id();
}
 ::google::protobuf::int32 AcknowledgeMessage::debug_response_id() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Server.AcknowledgeMessage.debug_response_id)
  return debug_response_id_;
}
 void AcknowledgeMessage::set_debug_response_id(::google::protobuf::int32 value) {
  set_has_debug_response_id();
  debug_response_id_ = value;
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Server.AcknowledgeMessage.debug_response_id)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

// ===================================================================

#ifndef _MSC_VER
const int FilterHitMessage::kFilterIdFieldNumber;
const int FilterHitMessage::kBrokenFieldNumber;
#endif  // !_MSC_VER

FilterHitMessage::FilterHitMessage()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:Hekate.Protobuf.Proto.Server.FilterHitMessage)
}

void FilterHitMessage::InitAsDefaultInstance() {
}

FilterHitMessage::FilterHitMessage(const FilterHitMessage& from)
  : ::google::protobuf::Message(),
    _internal_metadata_(NULL) {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:Hekate.Protobuf.Proto.Server.FilterHitMessage)
}

void FilterHitMessage::SharedCtor() {
  _cached_size_ = 0;
  filter_id_ = 0;
  broken_ = false;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

FilterHitMessage::~FilterHitMessage() {
  // @@protoc_insertion_point(destructor:Hekate.Protobuf.Proto.Server.FilterHitMessage)
  SharedDtor();
}

void FilterHitMessage::SharedDtor() {
  if (this != default_instance_) {
  }
}

void FilterHitMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* FilterHitMessage::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return FilterHitMessage_descriptor_;
}

const FilterHitMessage& FilterHitMessage::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_HekateServerProto_2eproto();
  return *default_instance_;
}

FilterHitMessage* FilterHitMessage::default_instance_ = NULL;

FilterHitMessage* FilterHitMessage::New(::google::protobuf::Arena* arena) const {
  FilterHitMessage* n = new FilterHitMessage;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void FilterHitMessage::Clear() {
#define ZR_HELPER_(f) reinterpret_cast<char*>(\
  &reinterpret_cast<FilterHitMessage*>(16)->f)

#define ZR_(first, last) do {\
  ::memset(&first, 0,\
           ZR_HELPER_(last) - ZR_HELPER_(first) + sizeof(last));\
} while (0)

  ZR_(filter_id_, broken_);

#undef ZR_HELPER_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  if (_internal_metadata_.have_unknown_fields()) {
    mutable_unknown_fields()->Clear();
  }
}

bool FilterHitMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:Hekate.Protobuf.Proto.Server.FilterHitMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required int32 filter_id = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &filter_id_)));
          set_has_filter_id();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_broken;
        break;
      }

      // required bool broken = 2;
      case 2: {
        if (tag == 16) {
         parse_broken:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &broken_)));
          set_has_broken();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:Hekate.Protobuf.Proto.Server.FilterHitMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:Hekate.Protobuf.Proto.Server.FilterHitMessage)
  return false;
#undef DO_
}

void FilterHitMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:Hekate.Protobuf.Proto.Server.FilterHitMessage)
  // required int32 filter_id = 1;
  if (has_filter_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->filter_id(), output);
  }

  // required bool broken = 2;
  if (has_broken()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->broken(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:Hekate.Protobuf.Proto.Server.FilterHitMessage)
}

::google::protobuf::uint8* FilterHitMessage::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:Hekate.Protobuf.Proto.Server.FilterHitMessage)
  // required int32 filter_id = 1;
  if (has_filter_id()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->filter_id(), target);
  }

  // required bool broken = 2;
  if (has_broken()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->broken(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:Hekate.Protobuf.Proto.Server.FilterHitMessage)
  return target;
}

int FilterHitMessage::RequiredFieldsByteSizeFallback() const {
  int total_size = 0;

  if (has_filter_id()) {
    // required int32 filter_id = 1;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int32Size(
        this->filter_id());
  }

  if (has_broken()) {
    // required bool broken = 2;
    total_size += 1 + 1;
  }

  return total_size;
}
int FilterHitMessage::ByteSize() const {
  int total_size = 0;

  if (((_has_bits_[0] & 0x00000003) ^ 0x00000003) == 0) {  // All required fields are present.
    // required int32 filter_id = 1;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int32Size(
        this->filter_id());

    // required bool broken = 2;
    total_size += 1 + 1;

  } else {
    total_size += RequiredFieldsByteSizeFallback();
  }
  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void FilterHitMessage::MergeFrom(const ::google::protobuf::Message& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  const FilterHitMessage* source = 
      ::google::protobuf::internal::DynamicCastToGenerated<const FilterHitMessage>(
          &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void FilterHitMessage::MergeFrom(const FilterHitMessage& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_filter_id()) {
      set_filter_id(from.filter_id());
    }
    if (from.has_broken()) {
      set_broken(from.broken());
    }
  }
  if (from._internal_metadata_.have_unknown_fields()) {
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
}

void FilterHitMessage::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void FilterHitMessage::CopyFrom(const FilterHitMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool FilterHitMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;

  return true;
}

void FilterHitMessage::Swap(FilterHitMessage* other) {
  if (other == this) return;
  InternalSwap(other);
}
void FilterHitMessage::InternalSwap(FilterHitMessage* other) {
  std::swap(filter_id_, other->filter_id_);
  std::swap(broken_, other->broken_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata FilterHitMessage::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = FilterHitMessage_descriptor_;
  metadata.reflection = FilterHitMessage_reflection_;
  return metadata;
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// FilterHitMessage

// required int32 filter_id = 1;
bool FilterHitMessage::has_filter_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void FilterHitMessage::set_has_filter_id() {
  _has_bits_[0] |= 0x00000001u;
}
void FilterHitMessage::clear_has_filter_id() {
  _has_bits_[0] &= ~0x00000001u;
}
void FilterHitMessage::clear_filter_id() {
  filter_id_ = 0;
  clear_has_filter_id();
}
 ::google::protobuf::int32 FilterHitMessage::filter_id() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Server.FilterHitMessage.filter_id)
  return filter_id_;
}
 void FilterHitMessage::set_filter_id(::google::protobuf::int32 value) {
  set_has_filter_id();
  filter_id_ = value;
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Server.FilterHitMessage.filter_id)
}

// required bool broken = 2;
bool FilterHitMessage::has_broken() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void FilterHitMessage::set_has_broken() {
  _has_bits_[0] |= 0x00000002u;
}
void FilterHitMessage::clear_has_broken() {
  _has_bits_[0] &= ~0x00000002u;
}
void FilterHitMessage::clear_broken() {
  broken_ = false;
  clear_has_broken();
}
 bool FilterHitMessage::broken() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Server.FilterHitMessage.broken)
  return broken_;
}
 void FilterHitMessage::set_broken(bool value) {
  set_has_broken();
  broken_ = value;
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Server.FilterHitMessage.broken)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

// ===================================================================

#ifndef _MSC_VER
const int HekateMessage::kHookInfoFieldNumber;
const int HekateMessage::kAcknowledgeFieldNumber;
#endif  // !_MSC_VER

HekateMessage::HekateMessage()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:Hekate.Protobuf.Proto.Server.HekateMessage)
}

void HekateMessage::InitAsDefaultInstance() {
  hook_info_ = const_cast< ::Hekate::Protobuf::Proto::Server::HekateToClientMessage*>(&::Hekate::Protobuf::Proto::Server::HekateToClientMessage::default_instance());
  acknowledge_ = const_cast< ::Hekate::Protobuf::Proto::Server::AcknowledgeMessage*>(&::Hekate::Protobuf::Proto::Server::AcknowledgeMessage::default_instance());
}

HekateMessage::HekateMessage(const HekateMessage& from)
  : ::google::protobuf::Message(),
    _internal_metadata_(NULL) {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:Hekate.Protobuf.Proto.Server.HekateMessage)
}

void HekateMessage::SharedCtor() {
  _cached_size_ = 0;
  hook_info_ = NULL;
  acknowledge_ = NULL;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

HekateMessage::~HekateMessage() {
  // @@protoc_insertion_point(destructor:Hekate.Protobuf.Proto.Server.HekateMessage)
  SharedDtor();
}

void HekateMessage::SharedDtor() {
  if (this != default_instance_) {
    delete hook_info_;
    delete acknowledge_;
  }
}

void HekateMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* HekateMessage::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return HekateMessage_descriptor_;
}

const HekateMessage& HekateMessage::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_HekateServerProto_2eproto();
  return *default_instance_;
}

HekateMessage* HekateMessage::default_instance_ = NULL;

HekateMessage* HekateMessage::New(::google::protobuf::Arena* arena) const {
  HekateMessage* n = new HekateMessage;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void HekateMessage::Clear() {
  if (_has_bits_[0 / 32] & 3u) {
    if (has_hook_info()) {
      if (hook_info_ != NULL) hook_info_->::Hekate::Protobuf::Proto::Server::HekateToClientMessage::Clear();
    }
    if (has_acknowledge()) {
      if (acknowledge_ != NULL) acknowledge_->::Hekate::Protobuf::Proto::Server::AcknowledgeMessage::Clear();
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  if (_internal_metadata_.have_unknown_fields()) {
    mutable_unknown_fields()->Clear();
  }
}

bool HekateMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:Hekate.Protobuf.Proto.Server.HekateMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required .Hekate.Protobuf.Proto.Server.HekateToClientMessage hook_info = 1;
      case 1: {
        if (tag == 10) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_hook_info()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_acknowledge;
        break;
      }

      // optional .Hekate.Protobuf.Proto.Server.AcknowledgeMessage acknowledge = 2;
      case 2: {
        if (tag == 18) {
         parse_acknowledge:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_acknowledge()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:Hekate.Protobuf.Proto.Server.HekateMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:Hekate.Protobuf.Proto.Server.HekateMessage)
  return false;
#undef DO_
}

void HekateMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:Hekate.Protobuf.Proto.Server.HekateMessage)
  // required .Hekate.Protobuf.Proto.Server.HekateToClientMessage hook_info = 1;
  if (has_hook_info()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, *this->hook_info_, output);
  }

  // optional .Hekate.Protobuf.Proto.Server.AcknowledgeMessage acknowledge = 2;
  if (has_acknowledge()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      2, *this->acknowledge_, output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:Hekate.Protobuf.Proto.Server.HekateMessage)
}

::google::protobuf::uint8* HekateMessage::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:Hekate.Protobuf.Proto.Server.HekateMessage)
  // required .Hekate.Protobuf.Proto.Server.HekateToClientMessage hook_info = 1;
  if (has_hook_info()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, *this->hook_info_, target);
  }

  // optional .Hekate.Protobuf.Proto.Server.AcknowledgeMessage acknowledge = 2;
  if (has_acknowledge()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        2, *this->acknowledge_, target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:Hekate.Protobuf.Proto.Server.HekateMessage)
  return target;
}

int HekateMessage::ByteSize() const {
  int total_size = 0;

  // required .Hekate.Protobuf.Proto.Server.HekateToClientMessage hook_info = 1;
  if (has_hook_info()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        *this->hook_info_);
  }
  // optional .Hekate.Protobuf.Proto.Server.AcknowledgeMessage acknowledge = 2;
  if (has_acknowledge()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        *this->acknowledge_);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void HekateMessage::MergeFrom(const ::google::protobuf::Message& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  const HekateMessage* source = 
      ::google::protobuf::internal::DynamicCastToGenerated<const HekateMessage>(
          &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void HekateMessage::MergeFrom(const HekateMessage& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_hook_info()) {
      mutable_hook_info()->::Hekate::Protobuf::Proto::Server::HekateToClientMessage::MergeFrom(from.hook_info());
    }
    if (from.has_acknowledge()) {
      mutable_acknowledge()->::Hekate::Protobuf::Proto::Server::AcknowledgeMessage::MergeFrom(from.acknowledge());
    }
  }
  if (from._internal_metadata_.have_unknown_fields()) {
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
}

void HekateMessage::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void HekateMessage::CopyFrom(const HekateMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool HekateMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;

  if (has_hook_info()) {
    if (!this->hook_info_->IsInitialized()) return false;
  }
  return true;
}

void HekateMessage::Swap(HekateMessage* other) {
  if (other == this) return;
  InternalSwap(other);
}
void HekateMessage::InternalSwap(HekateMessage* other) {
  std::swap(hook_info_, other->hook_info_);
  std::swap(acknowledge_, other->acknowledge_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata HekateMessage::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = HekateMessage_descriptor_;
  metadata.reflection = HekateMessage_reflection_;
  return metadata;
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// HekateMessage

// required .Hekate.Protobuf.Proto.Server.HekateToClientMessage hook_info = 1;
bool HekateMessage::has_hook_info() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void HekateMessage::set_has_hook_info() {
  _has_bits_[0] |= 0x00000001u;
}
void HekateMessage::clear_has_hook_info() {
  _has_bits_[0] &= ~0x00000001u;
}
void HekateMessage::clear_hook_info() {
  if (hook_info_ != NULL) hook_info_->::Hekate::Protobuf::Proto::Server::HekateToClientMessage::Clear();
  clear_has_hook_info();
}
 const ::Hekate::Protobuf::Proto::Server::HekateToClientMessage& HekateMessage::hook_info() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Server.HekateMessage.hook_info)
  return hook_info_ != NULL ? *hook_info_ : *default_instance_->hook_info_;
}
 ::Hekate::Protobuf::Proto::Server::HekateToClientMessage* HekateMessage::mutable_hook_info() {
  set_has_hook_info();
  if (hook_info_ == NULL) {
    hook_info_ = new ::Hekate::Protobuf::Proto::Server::HekateToClientMessage;
  }
  // @@protoc_insertion_point(field_mutable:Hekate.Protobuf.Proto.Server.HekateMessage.hook_info)
  return hook_info_;
}
 ::Hekate::Protobuf::Proto::Server::HekateToClientMessage* HekateMessage::release_hook_info() {
  clear_has_hook_info();
  ::Hekate::Protobuf::Proto::Server::HekateToClientMessage* temp = hook_info_;
  hook_info_ = NULL;
  return temp;
}
 void HekateMessage::set_allocated_hook_info(::Hekate::Protobuf::Proto::Server::HekateToClientMessage* hook_info) {
  delete hook_info_;
  hook_info_ = hook_info;
  if (hook_info) {
    set_has_hook_info();
  } else {
    clear_has_hook_info();
  }
  // @@protoc_insertion_point(field_set_allocated:Hekate.Protobuf.Proto.Server.HekateMessage.hook_info)
}

// optional .Hekate.Protobuf.Proto.Server.AcknowledgeMessage acknowledge = 2;
bool HekateMessage::has_acknowledge() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void HekateMessage::set_has_acknowledge() {
  _has_bits_[0] |= 0x00000002u;
}
void HekateMessage::clear_has_acknowledge() {
  _has_bits_[0] &= ~0x00000002u;
}
void HekateMessage::clear_acknowledge() {
  if (acknowledge_ != NULL) acknowledge_->::Hekate::Protobuf::Proto::Server::AcknowledgeMessage::Clear();
  clear_has_acknowledge();
}
 const ::Hekate::Protobuf::Proto::Server::AcknowledgeMessage& HekateMessage::acknowledge() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Server.HekateMessage.acknowledge)
  return acknowledge_ != NULL ? *acknowledge_ : *default_instance_->acknowledge_;
}
 ::Hekate::Protobuf::Proto::Server::AcknowledgeMessage* HekateMessage::mutable_acknowledge() {
  set_has_acknowledge();
  if (acknowledge_ == NULL) {
    acknowledge_ = new ::Hekate::Protobuf::Proto::Server::AcknowledgeMessage;
  }
  // @@protoc_insertion_point(field_mutable:Hekate.Protobuf.Proto.Server.HekateMessage.acknowledge)
  return acknowledge_;
}
 ::Hekate::Protobuf::Proto::Server::AcknowledgeMessage* HekateMessage::release_acknowledge() {
  clear_has_acknowledge();
  ::Hekate::Protobuf::Proto::Server::AcknowledgeMessage* temp = acknowledge_;
  acknowledge_ = NULL;
  return temp;
}
 void HekateMessage::set_allocated_acknowledge(::Hekate::Protobuf::Proto::Server::AcknowledgeMessage* acknowledge) {
  delete acknowledge_;
  acknowledge_ = acknowledge;
  if (acknowledge) {
    set_has_acknowledge();
  } else {
    clear_has_acknowledge();
  }
  // @@protoc_insertion_point(field_set_allocated:Hekate.Protobuf.Proto.Server.HekateMessage.acknowledge)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

// @@protoc_insertion_point(namespace_scope)

}  // namespace Server
}  // namespace Proto
}  // namespace Protobuf
}  // namespace Hekate

// @@protoc_insertion_point(global_scope)
