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

#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
#include "HekateClientProto.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 Client {

namespace {

const ::google::protobuf::Descriptor* AddHookMessage_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  AddHookMessage_reflection_ = NULL;
const ::google::protobuf::Descriptor* RemoveHookMessage_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  RemoveHookMessage_reflection_ = NULL;
const ::google::protobuf::Descriptor* ByteFilterMessage_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  ByteFilterMessage_reflection_ = NULL;
const ::google::protobuf::Descriptor* SubstringFilterMessage_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  SubstringFilterMessage_reflection_ = NULL;
const ::google::protobuf::Descriptor* LengthFilterMessage_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  LengthFilterMessage_reflection_ = NULL;
const ::google::protobuf::Descriptor* SubstituteMessage_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  SubstituteMessage_reflection_ = NULL;
const ::google::protobuf::Descriptor* ReplacementMessage_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  ReplacementMessage_reflection_ = NULL;
const ::google::protobuf::Descriptor* AddFilterMessage_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  AddFilterMessage_reflection_ = NULL;
const ::google::protobuf::Descriptor* RemoveFilterMessage_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  RemoveFilterMessage_reflection_ = NULL;
const ::google::protobuf::Descriptor* ReplayMessage_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  ReplayMessage_reflection_ = NULL;
const ::google::protobuf::Descriptor* ClientToHekateMessage_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  ClientToHekateMessage_reflection_ = NULL;
const ::google::protobuf::Descriptor* HekateClientMessage_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  HekateClientMessage_reflection_ = NULL;
const ::google::protobuf::EnumDescriptor* FilterType_descriptor_ = NULL;
const ::google::protobuf::EnumDescriptor* LengthType_descriptor_ = NULL;
const ::google::protobuf::EnumDescriptor* MessageType_descriptor_ = NULL;

}  // namespace


void protobuf_AssignDesc_HekateClientProto_2eproto() {
  protobuf_AddDesc_HekateClientProto_2eproto();
  const ::google::protobuf::FileDescriptor* file =
    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
      "HekateClientProto.proto");
  GOOGLE_CHECK(file != NULL);
  AddHookMessage_descriptor_ = file->message_type(0);
  static const int AddHookMessage_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddHookMessage, name_),
  };
  AddHookMessage_reflection_ =
    ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection(
      AddHookMessage_descriptor_,
      AddHookMessage::default_instance_,
      AddHookMessage_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddHookMessage, _has_bits_[0]),
      -1,
      -1,
      sizeof(AddHookMessage),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddHookMessage, _internal_metadata_),
      -1);
  RemoveHookMessage_descriptor_ = file->message_type(1);
  static const int RemoveHookMessage_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RemoveHookMessage, name_),
  };
  RemoveHookMessage_reflection_ =
    ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection(
      RemoveHookMessage_descriptor_,
      RemoveHookMessage::default_instance_,
      RemoveHookMessage_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RemoveHookMessage, _has_bits_[0]),
      -1,
      -1,
      sizeof(RemoveHookMessage),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RemoveHookMessage, _internal_metadata_),
      -1);
  ByteFilterMessage_descriptor_ = file->message_type(2);
  static const int ByteFilterMessage_offsets_[3] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ByteFilterMessage, byte_value_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ByteFilterMessage, byte_index_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ByteFilterMessage, byte_count_),
  };
  ByteFilterMessage_reflection_ =
    ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection(
      ByteFilterMessage_descriptor_,
      ByteFilterMessage::default_instance_,
      ByteFilterMessage_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ByteFilterMessage, _has_bits_[0]),
      -1,
      -1,
      sizeof(ByteFilterMessage),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ByteFilterMessage, _internal_metadata_),
      -1);
  SubstringFilterMessage_descriptor_ = file->message_type(3);
  static const int SubstringFilterMessage_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubstringFilterMessage, match_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubstringFilterMessage, length_),
  };
  SubstringFilterMessage_reflection_ =
    ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection(
      SubstringFilterMessage_descriptor_,
      SubstringFilterMessage::default_instance_,
      SubstringFilterMessage_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubstringFilterMessage, _has_bits_[0]),
      -1,
      -1,
      sizeof(SubstringFilterMessage),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubstringFilterMessage, _internal_metadata_),
      -1);
  LengthFilterMessage_descriptor_ = file->message_type(4);
  static const int LengthFilterMessage_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LengthFilterMessage, length_value_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LengthFilterMessage, length_type_),
  };
  LengthFilterMessage_reflection_ =
    ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection(
      LengthFilterMessage_descriptor_,
      LengthFilterMessage::default_instance_,
      LengthFilterMessage_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LengthFilterMessage, _has_bits_[0]),
      -1,
      -1,
      sizeof(LengthFilterMessage),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LengthFilterMessage, _internal_metadata_),
      -1);
  SubstituteMessage_descriptor_ = file->message_type(5);
  static const int SubstituteMessage_offsets_[3] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubstituteMessage, byte_value_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubstituteMessage, byte_index_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubstituteMessage, byte_count_),
  };
  SubstituteMessage_reflection_ =
    ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection(
      SubstituteMessage_descriptor_,
      SubstituteMessage::default_instance_,
      SubstituteMessage_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubstituteMessage, _has_bits_[0]),
      -1,
      -1,
      sizeof(SubstituteMessage),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubstituteMessage, _internal_metadata_),
      -1);
  ReplacementMessage_descriptor_ = file->message_type(6);
  static const int ReplacementMessage_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReplacementMessage, buffer_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReplacementMessage, length_),
  };
  ReplacementMessage_reflection_ =
    ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection(
      ReplacementMessage_descriptor_,
      ReplacementMessage::default_instance_,
      ReplacementMessage_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReplacementMessage, _has_bits_[0]),
      -1,
      -1,
      sizeof(ReplacementMessage),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReplacementMessage, _internal_metadata_),
      -1);
  AddFilterMessage_descriptor_ = file->message_type(7);
  static const int AddFilterMessage_offsets_[8] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddFilterMessage, type_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddFilterMessage, filter_id_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddFilterMessage, break_on_hit_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddFilterMessage, byte_filter_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddFilterMessage, length_filter_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddFilterMessage, string_filter_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddFilterMessage, substitute_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddFilterMessage, replacement_),
  };
  AddFilterMessage_reflection_ =
    ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection(
      AddFilterMessage_descriptor_,
      AddFilterMessage::default_instance_,
      AddFilterMessage_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddFilterMessage, _has_bits_[0]),
      -1,
      -1,
      sizeof(AddFilterMessage),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddFilterMessage, _internal_metadata_),
      -1);
  RemoveFilterMessage_descriptor_ = file->message_type(8);
  static const int RemoveFilterMessage_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RemoveFilterMessage, filter_id_),
  };
  RemoveFilterMessage_reflection_ =
    ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection(
      RemoveFilterMessage_descriptor_,
      RemoveFilterMessage::default_instance_,
      RemoveFilterMessage_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RemoveFilterMessage, _has_bits_[0]),
      -1,
      -1,
      sizeof(RemoveFilterMessage),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RemoveFilterMessage, _internal_metadata_),
      -1);
  ReplayMessage_descriptor_ = file->message_type(9);
  static const int ReplayMessage_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReplayMessage, message_),
  };
  ReplayMessage_reflection_ =
    ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection(
      ReplayMessage_descriptor_,
      ReplayMessage::default_instance_,
      ReplayMessage_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReplayMessage, _has_bits_[0]),
      -1,
      -1,
      sizeof(ReplayMessage),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReplayMessage, _internal_metadata_),
      -1);
  ClientToHekateMessage_descriptor_ = file->message_type(10);
  static const int ClientToHekateMessage_offsets_[7] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClientToHekateMessage, type_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClientToHekateMessage, add_hook_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClientToHekateMessage, remove_hook_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClientToHekateMessage, add_filter_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClientToHekateMessage, remove_filter_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClientToHekateMessage, replay_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClientToHekateMessage, continue__),
  };
  ClientToHekateMessage_reflection_ =
    ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection(
      ClientToHekateMessage_descriptor_,
      ClientToHekateMessage::default_instance_,
      ClientToHekateMessage_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClientToHekateMessage, _has_bits_[0]),
      -1,
      -1,
      sizeof(ClientToHekateMessage),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClientToHekateMessage, _internal_metadata_),
      -1);
  HekateClientMessage_descriptor_ = file->message_type(11);
  static const int HekateClientMessage_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(HekateClientMessage, clientmessage_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(HekateClientMessage, debug_response_id_),
  };
  HekateClientMessage_reflection_ =
    ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection(
      HekateClientMessage_descriptor_,
      HekateClientMessage::default_instance_,
      HekateClientMessage_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(HekateClientMessage, _has_bits_[0]),
      -1,
      -1,
      sizeof(HekateClientMessage),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(HekateClientMessage, _internal_metadata_),
      -1);
  FilterType_descriptor_ = file->enum_type(0);
  LengthType_descriptor_ = file->enum_type(1);
  MessageType_descriptor_ = file->enum_type(2);
}

namespace {

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

void protobuf_RegisterTypes(const ::std::string&) {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      AddHookMessage_descriptor_, &AddHookMessage::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      RemoveHookMessage_descriptor_, &RemoveHookMessage::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      ByteFilterMessage_descriptor_, &ByteFilterMessage::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      SubstringFilterMessage_descriptor_, &SubstringFilterMessage::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      LengthFilterMessage_descriptor_, &LengthFilterMessage::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      SubstituteMessage_descriptor_, &SubstituteMessage::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      ReplacementMessage_descriptor_, &ReplacementMessage::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      AddFilterMessage_descriptor_, &AddFilterMessage::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      RemoveFilterMessage_descriptor_, &RemoveFilterMessage::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      ReplayMessage_descriptor_, &ReplayMessage::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      ClientToHekateMessage_descriptor_, &ClientToHekateMessage::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      HekateClientMessage_descriptor_, &HekateClientMessage::default_instance());
}

}  // namespace

void protobuf_ShutdownFile_HekateClientProto_2eproto() {
  delete AddHookMessage::default_instance_;
  delete AddHookMessage_reflection_;
  delete RemoveHookMessage::default_instance_;
  delete RemoveHookMessage_reflection_;
  delete ByteFilterMessage::default_instance_;
  delete ByteFilterMessage_reflection_;
  delete SubstringFilterMessage::default_instance_;
  delete SubstringFilterMessage_reflection_;
  delete LengthFilterMessage::default_instance_;
  delete LengthFilterMessage_reflection_;
  delete SubstituteMessage::default_instance_;
  delete SubstituteMessage_reflection_;
  delete ReplacementMessage::default_instance_;
  delete ReplacementMessage_reflection_;
  delete AddFilterMessage::default_instance_;
  delete AddFilterMessage_reflection_;
  delete RemoveFilterMessage::default_instance_;
  delete RemoveFilterMessage_reflection_;
  delete ReplayMessage::default_instance_;
  delete ReplayMessage_reflection_;
  delete ClientToHekateMessage::default_instance_;
  delete ClientToHekateMessage_reflection_;
  delete HekateClientMessage::default_instance_;
  delete HekateClientMessage_reflection_;
}

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

  ::Hekate::Protobuf::Proto::Server::protobuf_AddDesc_HekateServerProto_2eproto();
  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
    "\n\027HekateClientProto.proto\022\034Hekate.Protob"
    "uf.Proto.Client\032\027HekateServerProto.proto"
    "\"\036\n\016AddHookMessage\022\014\n\004name\030\001 \002(\t\"!\n\021Remo"
    "veHookMessage\022\014\n\004name\030\001 \002(\t\"O\n\021ByteFilte"
    "rMessage\022\022\n\nbyte_value\030\001 \003(\005\022\022\n\nbyte_ind"
    "ex\030\002 \003(\005\022\022\n\nbyte_count\030\003 \002(\005\"7\n\026Substrin"
    "gFilterMessage\022\r\n\005match\030\001 \002(\014\022\016\n\006length\030"
    "\002 \002(\005\"j\n\023LengthFilterMessage\022\024\n\014length_v"
    "alue\030\001 \002(\005\022=\n\013length_type\030\002 \002(\0162(.Hekate"
    ".Protobuf.Proto.Client.LengthType\"O\n\021Sub"
    "stituteMessage\022\022\n\nbyte_value\030\001 \003(\005\022\022\n\nby"
    "te_index\030\002 \003(\005\022\022\n\nbyte_count\030\003 \002(\005\"4\n\022Re"
    "placementMessage\022\016\n\006buffer\030\001 \002(\014\022\016\n\006leng"
    "th\030\002 \002(\005\"\334\003\n\020AddFilterMessage\0226\n\004type\030\001 "
    "\002(\0162(.Hekate.Protobuf.Proto.Client.Filte"
    "rType\022\021\n\tfilter_id\030\002 \002(\005\022\024\n\014break_on_hit"
    "\030\003 \002(\010\022D\n\013byte_filter\030\004 \001(\0132/.Hekate.Pro"
    "tobuf.Proto.Client.ByteFilterMessage\022H\n\r"
    "length_filter\030\005 \001(\01321.Hekate.Protobuf.Pr"
    "oto.Client.LengthFilterMessage\022K\n\rstring"
    "_filter\030\006 \001(\01324.Hekate.Protobuf.Proto.Cl"
    "ient.SubstringFilterMessage\022C\n\nsubstitut"
    "e\030\007 \001(\0132/.Hekate.Protobuf.Proto.Client.S"
    "ubstituteMessage\022E\n\013replacement\030\010 \001(\01320."
    "Hekate.Protobuf.Proto.Client.Replacement"
    "Message\"(\n\023RemoveFilterMessage\022\021\n\tfilter"
    "_id\030\001 \002(\005\"U\n\rReplayMessage\022D\n\007message\030\001 "
    "\002(\01323.Hekate.Protobuf.Proto.Server.Hekat"
    "eToClientMessage\"\263\003\n\025ClientToHekateMessa"
    "ge\0227\n\004type\030\001 \002(\0162).Hekate.Protobuf.Proto"
    ".Client.MessageType\022>\n\010add_hook\030\002 \001(\0132,."
    "Hekate.Protobuf.Proto.Client.AddHookMess"
    "age\022D\n\013remove_hook\030\003 \001(\0132/.Hekate.Protob"
    "uf.Proto.Client.RemoveHookMessage\022B\n\nadd"
    "_filter\030\004 \001(\0132..Hekate.Protobuf.Proto.Cl"
    "ient.AddFilterMessage\022H\n\rremove_filter\030\005"
    " \001(\01321.Hekate.Protobuf.Proto.Client.Remo"
    "veFilterMessage\022;\n\006replay\030\006 \001(\0132+.Hekate"
    ".Protobuf.Proto.Client.ReplayMessage\022\020\n\010"
    "continue\030\007 \001(\010\"|\n\023HekateClientMessage\022J\n"
    "\rclientMessage\030\001 \002(\01323.Hekate.Protobuf.P"
    "roto.Client.ClientToHekateMessage\022\031\n\021deb"
    "ug_response_id\030\002 \001(\005*1\n\nFilterType\022\010\n\004BY"
    "TE\020\000\022\n\n\006LENGTH\020\001\022\r\n\tSUBSTRING\020\002*.\n\nLengt"
    "hType\022\010\n\004LESS\020\000\022\t\n\005EQUAL\020\001\022\013\n\007GREATER\020\002*"
    "t\n\013MessageType\022\014\n\010ADD_HOOK\020\000\022\017\n\013REMOVE_H"
    "OOK\020\001\022\016\n\nADD_FILTER\020\002\022\021\n\rREMOVE_FILTER\020\003"
    "\022\t\n\005PAUSE\020\004\022\014\n\010CONTINUE\020\005\022\n\n\006REPLAY\020\006", 1917);
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
    "HekateClientProto.proto", &protobuf_RegisterTypes);
  AddHookMessage::default_instance_ = new AddHookMessage();
  RemoveHookMessage::default_instance_ = new RemoveHookMessage();
  ByteFilterMessage::default_instance_ = new ByteFilterMessage();
  SubstringFilterMessage::default_instance_ = new SubstringFilterMessage();
  LengthFilterMessage::default_instance_ = new LengthFilterMessage();
  SubstituteMessage::default_instance_ = new SubstituteMessage();
  ReplacementMessage::default_instance_ = new ReplacementMessage();
  AddFilterMessage::default_instance_ = new AddFilterMessage();
  RemoveFilterMessage::default_instance_ = new RemoveFilterMessage();
  ReplayMessage::default_instance_ = new ReplayMessage();
  ClientToHekateMessage::default_instance_ = new ClientToHekateMessage();
  HekateClientMessage::default_instance_ = new HekateClientMessage();
  AddHookMessage::default_instance_->InitAsDefaultInstance();
  RemoveHookMessage::default_instance_->InitAsDefaultInstance();
  ByteFilterMessage::default_instance_->InitAsDefaultInstance();
  SubstringFilterMessage::default_instance_->InitAsDefaultInstance();
  LengthFilterMessage::default_instance_->InitAsDefaultInstance();
  SubstituteMessage::default_instance_->InitAsDefaultInstance();
  ReplacementMessage::default_instance_->InitAsDefaultInstance();
  AddFilterMessage::default_instance_->InitAsDefaultInstance();
  RemoveFilterMessage::default_instance_->InitAsDefaultInstance();
  ReplayMessage::default_instance_->InitAsDefaultInstance();
  ClientToHekateMessage::default_instance_->InitAsDefaultInstance();
  HekateClientMessage::default_instance_->InitAsDefaultInstance();
  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_HekateClientProto_2eproto);
}

// Force AddDescriptors() to be called at static initialization time.
struct StaticDescriptorInitializer_HekateClientProto_2eproto {
  StaticDescriptorInitializer_HekateClientProto_2eproto() {
    protobuf_AddDesc_HekateClientProto_2eproto();
  }
} static_descriptor_initializer_HekateClientProto_2eproto_;
const ::google::protobuf::EnumDescriptor* FilterType_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return FilterType_descriptor_;
}
bool FilterType_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

const ::google::protobuf::EnumDescriptor* LengthType_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return LengthType_descriptor_;
}
bool LengthType_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

const ::google::protobuf::EnumDescriptor* MessageType_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return MessageType_descriptor_;
}
bool MessageType_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
      return true;
    default:
      return false;
  }
}


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 AddHookMessage::kNameFieldNumber;
#endif  // !_MSC_VER

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

void AddHookMessage::InitAsDefaultInstance() {
}

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

void AddHookMessage::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

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

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

const AddHookMessage& AddHookMessage::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_HekateClientProto_2eproto();
  return *default_instance_;
}

AddHookMessage* AddHookMessage::default_instance_ = NULL;

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

void AddHookMessage::Clear() {
  if (has_name()) {
    name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  if (_internal_metadata_.have_unknown_fields()) {
    mutable_unknown_fields()->Clear();
  }
}

bool AddHookMessage::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.Client.AddHookMessage)
  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 string name = 1;
      case 1: {
        if (tag == 10) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_name()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->name().data(), this->name().length(),
            ::google::protobuf::internal::WireFormat::PARSE,
            "Hekate.Protobuf.Proto.Client.AddHookMessage.name");
        } 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.Client.AddHookMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:Hekate.Protobuf.Proto.Client.AddHookMessage)
  return false;
#undef DO_
}

void AddHookMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:Hekate.Protobuf.Proto.Client.AddHookMessage)
  // required string name = 1;
  if (has_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->name().data(), this->name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "Hekate.Protobuf.Proto.Client.AddHookMessage.name");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->name(), output);
  }

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

::google::protobuf::uint8* AddHookMessage::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:Hekate.Protobuf.Proto.Client.AddHookMessage)
  // required string name = 1;
  if (has_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->name().data(), this->name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "Hekate.Protobuf.Proto.Client.AddHookMessage.name");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        1, this->name(), 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.Client.AddHookMessage)
  return target;
}

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

  // required string name = 1;
  if (has_name()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::StringSize(
        this->name());
  }
  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 AddHookMessage::MergeFrom(const ::google::protobuf::Message& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  const AddHookMessage* source = 
      ::google::protobuf::internal::DynamicCastToGenerated<const AddHookMessage>(
          &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void AddHookMessage::MergeFrom(const AddHookMessage& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_name()) {
      set_has_name();
      name_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.name_);
    }
  }
  if (from._internal_metadata_.have_unknown_fields()) {
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
}

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

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

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

  return true;
}

void AddHookMessage::Swap(AddHookMessage* other) {
  if (other == this) return;
  InternalSwap(other);
}
void AddHookMessage::InternalSwap(AddHookMessage* other) {
  name_.Swap(&other->name_);
  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 AddHookMessage::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = AddHookMessage_descriptor_;
  metadata.reflection = AddHookMessage_reflection_;
  return metadata;
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// AddHookMessage

// required string name = 1;
bool AddHookMessage::has_name() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void AddHookMessage::set_has_name() {
  _has_bits_[0] |= 0x00000001u;
}
void AddHookMessage::clear_has_name() {
  _has_bits_[0] &= ~0x00000001u;
}
void AddHookMessage::clear_name() {
  name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_name();
}
 const ::std::string& AddHookMessage::name() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Client.AddHookMessage.name)
  return name_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
 void AddHookMessage::set_name(const ::std::string& value) {
  set_has_name();
  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Client.AddHookMessage.name)
}
 void AddHookMessage::set_name(const char* value) {
  set_has_name();
  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:Hekate.Protobuf.Proto.Client.AddHookMessage.name)
}
 void AddHookMessage::set_name(const char* value, size_t size) {
  set_has_name();
  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:Hekate.Protobuf.Proto.Client.AddHookMessage.name)
}
 ::std::string* AddHookMessage::mutable_name() {
  set_has_name();
  // @@protoc_insertion_point(field_mutable:Hekate.Protobuf.Proto.Client.AddHookMessage.name)
  return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
 ::std::string* AddHookMessage::release_name() {
  clear_has_name();
  return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
 void AddHookMessage::set_allocated_name(::std::string* name) {
  if (name != NULL) {
    set_has_name();
  } else {
    clear_has_name();
  }
  name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name);
  // @@protoc_insertion_point(field_set_allocated:Hekate.Protobuf.Proto.Client.AddHookMessage.name)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#ifndef _MSC_VER
const int RemoveHookMessage::kNameFieldNumber;
#endif  // !_MSC_VER

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

void RemoveHookMessage::InitAsDefaultInstance() {
}

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

void RemoveHookMessage::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

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

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

const RemoveHookMessage& RemoveHookMessage::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_HekateClientProto_2eproto();
  return *default_instance_;
}

RemoveHookMessage* RemoveHookMessage::default_instance_ = NULL;

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

void RemoveHookMessage::Clear() {
  if (has_name()) {
    name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  if (_internal_metadata_.have_unknown_fields()) {
    mutable_unknown_fields()->Clear();
  }
}

bool RemoveHookMessage::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.Client.RemoveHookMessage)
  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 string name = 1;
      case 1: {
        if (tag == 10) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_name()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->name().data(), this->name().length(),
            ::google::protobuf::internal::WireFormat::PARSE,
            "Hekate.Protobuf.Proto.Client.RemoveHookMessage.name");
        } 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.Client.RemoveHookMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:Hekate.Protobuf.Proto.Client.RemoveHookMessage)
  return false;
#undef DO_
}

void RemoveHookMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:Hekate.Protobuf.Proto.Client.RemoveHookMessage)
  // required string name = 1;
  if (has_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->name().data(), this->name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "Hekate.Protobuf.Proto.Client.RemoveHookMessage.name");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->name(), output);
  }

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

::google::protobuf::uint8* RemoveHookMessage::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:Hekate.Protobuf.Proto.Client.RemoveHookMessage)
  // required string name = 1;
  if (has_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->name().data(), this->name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "Hekate.Protobuf.Proto.Client.RemoveHookMessage.name");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        1, this->name(), 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.Client.RemoveHookMessage)
  return target;
}

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

  // required string name = 1;
  if (has_name()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::StringSize(
        this->name());
  }
  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 RemoveHookMessage::MergeFrom(const ::google::protobuf::Message& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  const RemoveHookMessage* source = 
      ::google::protobuf::internal::DynamicCastToGenerated<const RemoveHookMessage>(
          &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void RemoveHookMessage::MergeFrom(const RemoveHookMessage& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_name()) {
      set_has_name();
      name_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.name_);
    }
  }
  if (from._internal_metadata_.have_unknown_fields()) {
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
}

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

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

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

  return true;
}

void RemoveHookMessage::Swap(RemoveHookMessage* other) {
  if (other == this) return;
  InternalSwap(other);
}
void RemoveHookMessage::InternalSwap(RemoveHookMessage* other) {
  name_.Swap(&other->name_);
  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 RemoveHookMessage::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = RemoveHookMessage_descriptor_;
  metadata.reflection = RemoveHookMessage_reflection_;
  return metadata;
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// RemoveHookMessage

// required string name = 1;
bool RemoveHookMessage::has_name() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void RemoveHookMessage::set_has_name() {
  _has_bits_[0] |= 0x00000001u;
}
void RemoveHookMessage::clear_has_name() {
  _has_bits_[0] &= ~0x00000001u;
}
void RemoveHookMessage::clear_name() {
  name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_name();
}
 const ::std::string& RemoveHookMessage::name() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Client.RemoveHookMessage.name)
  return name_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
 void RemoveHookMessage::set_name(const ::std::string& value) {
  set_has_name();
  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Client.RemoveHookMessage.name)
}
 void RemoveHookMessage::set_name(const char* value) {
  set_has_name();
  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:Hekate.Protobuf.Proto.Client.RemoveHookMessage.name)
}
 void RemoveHookMessage::set_name(const char* value, size_t size) {
  set_has_name();
  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:Hekate.Protobuf.Proto.Client.RemoveHookMessage.name)
}
 ::std::string* RemoveHookMessage::mutable_name() {
  set_has_name();
  // @@protoc_insertion_point(field_mutable:Hekate.Protobuf.Proto.Client.RemoveHookMessage.name)
  return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
 ::std::string* RemoveHookMessage::release_name() {
  clear_has_name();
  return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
 void RemoveHookMessage::set_allocated_name(::std::string* name) {
  if (name != NULL) {
    set_has_name();
  } else {
    clear_has_name();
  }
  name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name);
  // @@protoc_insertion_point(field_set_allocated:Hekate.Protobuf.Proto.Client.RemoveHookMessage.name)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#ifndef _MSC_VER
const int ByteFilterMessage::kByteValueFieldNumber;
const int ByteFilterMessage::kByteIndexFieldNumber;
const int ByteFilterMessage::kByteCountFieldNumber;
#endif  // !_MSC_VER

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

void ByteFilterMessage::InitAsDefaultInstance() {
}

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

void ByteFilterMessage::SharedCtor() {
  _cached_size_ = 0;
  byte_count_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

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

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

const ByteFilterMessage& ByteFilterMessage::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_HekateClientProto_2eproto();
  return *default_instance_;
}

ByteFilterMessage* ByteFilterMessage::default_instance_ = NULL;

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

void ByteFilterMessage::Clear() {
  byte_count_ = 0;
  byte_value_.Clear();
  byte_index_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  if (_internal_metadata_.have_unknown_fields()) {
    mutable_unknown_fields()->Clear();
  }
}

bool ByteFilterMessage::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.Client.ByteFilterMessage)
  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)) {
      // repeated int32 byte_value = 1;
      case 1: {
        if (tag == 8) {
         parse_byte_value:
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 1, 8, input, this->mutable_byte_value())));
        } else if (tag == 10) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, this->mutable_byte_value())));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(8)) goto parse_byte_value;
        if (input->ExpectTag(16)) goto parse_byte_index;
        break;
      }

      // repeated int32 byte_index = 2;
      case 2: {
        if (tag == 16) {
         parse_byte_index:
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 1, 16, input, this->mutable_byte_index())));
        } else if (tag == 18) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, this->mutable_byte_index())));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_byte_index;
        if (input->ExpectTag(24)) goto parse_byte_count;
        break;
      }

      // required int32 byte_count = 3;
      case 3: {
        if (tag == 24) {
         parse_byte_count:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &byte_count_)));
          set_has_byte_count();
        } 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.Client.ByteFilterMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:Hekate.Protobuf.Proto.Client.ByteFilterMessage)
  return false;
#undef DO_
}

void ByteFilterMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:Hekate.Protobuf.Proto.Client.ByteFilterMessage)
  // repeated int32 byte_value = 1;
  for (int i = 0; i < this->byte_value_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(
      1, this->byte_value(i), output);
  }

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

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

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

::google::protobuf::uint8* ByteFilterMessage::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:Hekate.Protobuf.Proto.Client.ByteFilterMessage)
  // repeated int32 byte_value = 1;
  for (int i = 0; i < this->byte_value_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteInt32ToArray(1, this->byte_value(i), target);
  }

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

  // required int32 byte_count = 3;
  if (has_byte_count()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->byte_count(), 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.Client.ByteFilterMessage)
  return target;
}

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

  // required int32 byte_count = 3;
  if (has_byte_count()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int32Size(
        this->byte_count());
  }
  // repeated int32 byte_value = 1;
  {
    int data_size = 0;
    for (int i = 0; i < this->byte_value_size(); i++) {
      data_size += ::google::protobuf::internal::WireFormatLite::
        Int32Size(this->byte_value(i));
    }
    total_size += 1 * this->byte_value_size() + data_size;
  }

  // repeated int32 byte_index = 2;
  {
    int data_size = 0;
    for (int i = 0; i < this->byte_index_size(); i++) {
      data_size += ::google::protobuf::internal::WireFormatLite::
        Int32Size(this->byte_index(i));
    }
    total_size += 1 * this->byte_index_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 ByteFilterMessage::MergeFrom(const ::google::protobuf::Message& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  const ByteFilterMessage* source = 
      ::google::protobuf::internal::DynamicCastToGenerated<const ByteFilterMessage>(
          &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void ByteFilterMessage::MergeFrom(const ByteFilterMessage& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  byte_value_.MergeFrom(from.byte_value_);
  byte_index_.MergeFrom(from.byte_index_);
  if (from._has_bits_[2 / 32] & (0xffu << (2 % 32))) {
    if (from.has_byte_count()) {
      set_byte_count(from.byte_count());
    }
  }
  if (from._internal_metadata_.have_unknown_fields()) {
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
}

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

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

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

  return true;
}

void ByteFilterMessage::Swap(ByteFilterMessage* other) {
  if (other == this) return;
  InternalSwap(other);
}
void ByteFilterMessage::InternalSwap(ByteFilterMessage* other) {
  byte_value_.UnsafeArenaSwap(&other->byte_value_);
  byte_index_.UnsafeArenaSwap(&other->byte_index_);
  std::swap(byte_count_, other->byte_count_);
  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 ByteFilterMessage::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = ByteFilterMessage_descriptor_;
  metadata.reflection = ByteFilterMessage_reflection_;
  return metadata;
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// ByteFilterMessage

// repeated int32 byte_value = 1;
int ByteFilterMessage::byte_value_size() const {
  return byte_value_.size();
}
void ByteFilterMessage::clear_byte_value() {
  byte_value_.Clear();
}
 ::google::protobuf::int32 ByteFilterMessage::byte_value(int index) const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Client.ByteFilterMessage.byte_value)
  return byte_value_.Get(index);
}
 void ByteFilterMessage::set_byte_value(int index, ::google::protobuf::int32 value) {
  byte_value_.Set(index, value);
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Client.ByteFilterMessage.byte_value)
}
 void ByteFilterMessage::add_byte_value(::google::protobuf::int32 value) {
  byte_value_.Add(value);
  // @@protoc_insertion_point(field_add:Hekate.Protobuf.Proto.Client.ByteFilterMessage.byte_value)
}
 const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
ByteFilterMessage::byte_value() const {
  // @@protoc_insertion_point(field_list:Hekate.Protobuf.Proto.Client.ByteFilterMessage.byte_value)
  return byte_value_;
}
 ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
ByteFilterMessage::mutable_byte_value() {
  // @@protoc_insertion_point(field_mutable_list:Hekate.Protobuf.Proto.Client.ByteFilterMessage.byte_value)
  return &byte_value_;
}

// repeated int32 byte_index = 2;
int ByteFilterMessage::byte_index_size() const {
  return byte_index_.size();
}
void ByteFilterMessage::clear_byte_index() {
  byte_index_.Clear();
}
 ::google::protobuf::int32 ByteFilterMessage::byte_index(int index) const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Client.ByteFilterMessage.byte_index)
  return byte_index_.Get(index);
}
 void ByteFilterMessage::set_byte_index(int index, ::google::protobuf::int32 value) {
  byte_index_.Set(index, value);
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Client.ByteFilterMessage.byte_index)
}
 void ByteFilterMessage::add_byte_index(::google::protobuf::int32 value) {
  byte_index_.Add(value);
  // @@protoc_insertion_point(field_add:Hekate.Protobuf.Proto.Client.ByteFilterMessage.byte_index)
}
 const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
ByteFilterMessage::byte_index() const {
  // @@protoc_insertion_point(field_list:Hekate.Protobuf.Proto.Client.ByteFilterMessage.byte_index)
  return byte_index_;
}
 ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
ByteFilterMessage::mutable_byte_index() {
  // @@protoc_insertion_point(field_mutable_list:Hekate.Protobuf.Proto.Client.ByteFilterMessage.byte_index)
  return &byte_index_;
}

// required int32 byte_count = 3;
bool ByteFilterMessage::has_byte_count() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
void ByteFilterMessage::set_has_byte_count() {
  _has_bits_[0] |= 0x00000004u;
}
void ByteFilterMessage::clear_has_byte_count() {
  _has_bits_[0] &= ~0x00000004u;
}
void ByteFilterMessage::clear_byte_count() {
  byte_count_ = 0;
  clear_has_byte_count();
}
 ::google::protobuf::int32 ByteFilterMessage::byte_count() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Client.ByteFilterMessage.byte_count)
  return byte_count_;
}
 void ByteFilterMessage::set_byte_count(::google::protobuf::int32 value) {
  set_has_byte_count();
  byte_count_ = value;
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Client.ByteFilterMessage.byte_count)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#ifndef _MSC_VER
const int SubstringFilterMessage::kMatchFieldNumber;
const int SubstringFilterMessage::kLengthFieldNumber;
#endif  // !_MSC_VER

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

void SubstringFilterMessage::InitAsDefaultInstance() {
}

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

void SubstringFilterMessage::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  match_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  length_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

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

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

const SubstringFilterMessage& SubstringFilterMessage::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_HekateClientProto_2eproto();
  return *default_instance_;
}

SubstringFilterMessage* SubstringFilterMessage::default_instance_ = NULL;

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

void SubstringFilterMessage::Clear() {
  if (_has_bits_[0 / 32] & 3u) {
    if (has_match()) {
      match_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    }
    length_ = 0;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  if (_internal_metadata_.have_unknown_fields()) {
    mutable_unknown_fields()->Clear();
  }
}

bool SubstringFilterMessage::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.Client.SubstringFilterMessage)
  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 bytes match = 1;
      case 1: {
        if (tag == 10) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_match()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_length;
        break;
      }

      // required int32 length = 2;
      case 2: {
        if (tag == 16) {
         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->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.Client.SubstringFilterMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:Hekate.Protobuf.Proto.Client.SubstringFilterMessage)
  return false;
#undef DO_
}

void SubstringFilterMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:Hekate.Protobuf.Proto.Client.SubstringFilterMessage)
  // required bytes match = 1;
  if (has_match()) {
    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
      1, this->match(), output);
  }

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

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

::google::protobuf::uint8* SubstringFilterMessage::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:Hekate.Protobuf.Proto.Client.SubstringFilterMessage)
  // required bytes match = 1;
  if (has_match()) {
    target =
      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
        1, this->match(), target);
  }

  // required int32 length = 2;
  if (has_length()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->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.Client.SubstringFilterMessage)
  return target;
}

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

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

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

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

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

    // required int32 length = 2;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int32Size(
        this->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 SubstringFilterMessage::MergeFrom(const ::google::protobuf::Message& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  const SubstringFilterMessage* source = 
      ::google::protobuf::internal::DynamicCastToGenerated<const SubstringFilterMessage>(
          &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void SubstringFilterMessage::MergeFrom(const SubstringFilterMessage& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_match()) {
      set_has_match();
      match_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.match_);
    }
    if (from.has_length()) {
      set_length(from.length());
    }
  }
  if (from._internal_metadata_.have_unknown_fields()) {
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
}

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

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

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

  return true;
}

void SubstringFilterMessage::Swap(SubstringFilterMessage* other) {
  if (other == this) return;
  InternalSwap(other);
}
void SubstringFilterMessage::InternalSwap(SubstringFilterMessage* other) {
  match_.Swap(&other->match_);
  std::swap(length_, other->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 SubstringFilterMessage::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = SubstringFilterMessage_descriptor_;
  metadata.reflection = SubstringFilterMessage_reflection_;
  return metadata;
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// SubstringFilterMessage

// required bytes match = 1;
bool SubstringFilterMessage::has_match() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void SubstringFilterMessage::set_has_match() {
  _has_bits_[0] |= 0x00000001u;
}
void SubstringFilterMessage::clear_has_match() {
  _has_bits_[0] &= ~0x00000001u;
}
void SubstringFilterMessage::clear_match() {
  match_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_match();
}
 const ::std::string& SubstringFilterMessage::match() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Client.SubstringFilterMessage.match)
  return match_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
 void SubstringFilterMessage::set_match(const ::std::string& value) {
  set_has_match();
  match_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Client.SubstringFilterMessage.match)
}
 void SubstringFilterMessage::set_match(const char* value) {
  set_has_match();
  match_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:Hekate.Protobuf.Proto.Client.SubstringFilterMessage.match)
}
 void SubstringFilterMessage::set_match(const void* value, size_t size) {
  set_has_match();
  match_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:Hekate.Protobuf.Proto.Client.SubstringFilterMessage.match)
}
 ::std::string* SubstringFilterMessage::mutable_match() {
  set_has_match();
  // @@protoc_insertion_point(field_mutable:Hekate.Protobuf.Proto.Client.SubstringFilterMessage.match)
  return match_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
 ::std::string* SubstringFilterMessage::release_match() {
  clear_has_match();
  return match_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
 void SubstringFilterMessage::set_allocated_match(::std::string* match) {
  if (match != NULL) {
    set_has_match();
  } else {
    clear_has_match();
  }
  match_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), match);
  // @@protoc_insertion_point(field_set_allocated:Hekate.Protobuf.Proto.Client.SubstringFilterMessage.match)
}

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

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#ifndef _MSC_VER
const int LengthFilterMessage::kLengthValueFieldNumber;
const int LengthFilterMessage::kLengthTypeFieldNumber;
#endif  // !_MSC_VER

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

void LengthFilterMessage::InitAsDefaultInstance() {
}

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

void LengthFilterMessage::SharedCtor() {
  _cached_size_ = 0;
  length_value_ = 0;
  length_type_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

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

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

const LengthFilterMessage& LengthFilterMessage::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_HekateClientProto_2eproto();
  return *default_instance_;
}

LengthFilterMessage* LengthFilterMessage::default_instance_ = NULL;

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

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

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

  ZR_(length_value_, length_type_);

#undef ZR_HELPER_
#undef ZR_

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

bool LengthFilterMessage::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.Client.LengthFilterMessage)
  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 length_value = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &length_value_)));
          set_has_length_value();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_length_type;
        break;
      }

      // required .Hekate.Protobuf.Proto.Client.LengthType length_type = 2;
      case 2: {
        if (tag == 16) {
         parse_length_type:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::Hekate::Protobuf::Proto::Client::LengthType_IsValid(value)) {
            set_length_type(static_cast< ::Hekate::Protobuf::Proto::Client::LengthType >(value));
          } else {
            mutable_unknown_fields()->AddVarint(2, value);
          }
        } 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.Client.LengthFilterMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:Hekate.Protobuf.Proto.Client.LengthFilterMessage)
  return false;
#undef DO_
}

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

  // required .Hekate.Protobuf.Proto.Client.LengthType length_type = 2;
  if (has_length_type()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      2, this->length_type(), output);
  }

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

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

  // required .Hekate.Protobuf.Proto.Client.LengthType length_type = 2;
  if (has_length_type()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      2, this->length_type(), 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.Client.LengthFilterMessage)
  return target;
}

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

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

  if (has_length_type()) {
    // required .Hekate.Protobuf.Proto.Client.LengthType length_type = 2;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::EnumSize(this->length_type());
  }

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

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

    // required .Hekate.Protobuf.Proto.Client.LengthType length_type = 2;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::EnumSize(this->length_type());

  } 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 LengthFilterMessage::MergeFrom(const ::google::protobuf::Message& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  const LengthFilterMessage* source = 
      ::google::protobuf::internal::DynamicCastToGenerated<const LengthFilterMessage>(
          &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void LengthFilterMessage::MergeFrom(const LengthFilterMessage& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_length_value()) {
      set_length_value(from.length_value());
    }
    if (from.has_length_type()) {
      set_length_type(from.length_type());
    }
  }
  if (from._internal_metadata_.have_unknown_fields()) {
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
}

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

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

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

  return true;
}

void LengthFilterMessage::Swap(LengthFilterMessage* other) {
  if (other == this) return;
  InternalSwap(other);
}
void LengthFilterMessage::InternalSwap(LengthFilterMessage* other) {
  std::swap(length_value_, other->length_value_);
  std::swap(length_type_, other->length_type_);
  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 LengthFilterMessage::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = LengthFilterMessage_descriptor_;
  metadata.reflection = LengthFilterMessage_reflection_;
  return metadata;
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// LengthFilterMessage

// required int32 length_value = 1;
bool LengthFilterMessage::has_length_value() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void LengthFilterMessage::set_has_length_value() {
  _has_bits_[0] |= 0x00000001u;
}
void LengthFilterMessage::clear_has_length_value() {
  _has_bits_[0] &= ~0x00000001u;
}
void LengthFilterMessage::clear_length_value() {
  length_value_ = 0;
  clear_has_length_value();
}
 ::google::protobuf::int32 LengthFilterMessage::length_value() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Client.LengthFilterMessage.length_value)
  return length_value_;
}
 void LengthFilterMessage::set_length_value(::google::protobuf::int32 value) {
  set_has_length_value();
  length_value_ = value;
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Client.LengthFilterMessage.length_value)
}

// required .Hekate.Protobuf.Proto.Client.LengthType length_type = 2;
bool LengthFilterMessage::has_length_type() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void LengthFilterMessage::set_has_length_type() {
  _has_bits_[0] |= 0x00000002u;
}
void LengthFilterMessage::clear_has_length_type() {
  _has_bits_[0] &= ~0x00000002u;
}
void LengthFilterMessage::clear_length_type() {
  length_type_ = 0;
  clear_has_length_type();
}
 ::Hekate::Protobuf::Proto::Client::LengthType LengthFilterMessage::length_type() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Client.LengthFilterMessage.length_type)
  return static_cast< ::Hekate::Protobuf::Proto::Client::LengthType >(length_type_);
}
 void LengthFilterMessage::set_length_type(::Hekate::Protobuf::Proto::Client::LengthType value) {
  assert(::Hekate::Protobuf::Proto::Client::LengthType_IsValid(value));
  set_has_length_type();
  length_type_ = value;
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Client.LengthFilterMessage.length_type)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#ifndef _MSC_VER
const int SubstituteMessage::kByteValueFieldNumber;
const int SubstituteMessage::kByteIndexFieldNumber;
const int SubstituteMessage::kByteCountFieldNumber;
#endif  // !_MSC_VER

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

void SubstituteMessage::InitAsDefaultInstance() {
}

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

void SubstituteMessage::SharedCtor() {
  _cached_size_ = 0;
  byte_count_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

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

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

const SubstituteMessage& SubstituteMessage::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_HekateClientProto_2eproto();
  return *default_instance_;
}

SubstituteMessage* SubstituteMessage::default_instance_ = NULL;

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

void SubstituteMessage::Clear() {
  byte_count_ = 0;
  byte_value_.Clear();
  byte_index_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  if (_internal_metadata_.have_unknown_fields()) {
    mutable_unknown_fields()->Clear();
  }
}

bool SubstituteMessage::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.Client.SubstituteMessage)
  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)) {
      // repeated int32 byte_value = 1;
      case 1: {
        if (tag == 8) {
         parse_byte_value:
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 1, 8, input, this->mutable_byte_value())));
        } else if (tag == 10) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, this->mutable_byte_value())));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(8)) goto parse_byte_value;
        if (input->ExpectTag(16)) goto parse_byte_index;
        break;
      }

      // repeated int32 byte_index = 2;
      case 2: {
        if (tag == 16) {
         parse_byte_index:
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 1, 16, input, this->mutable_byte_index())));
        } else if (tag == 18) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, this->mutable_byte_index())));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_byte_index;
        if (input->ExpectTag(24)) goto parse_byte_count;
        break;
      }

      // required int32 byte_count = 3;
      case 3: {
        if (tag == 24) {
         parse_byte_count:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &byte_count_)));
          set_has_byte_count();
        } 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.Client.SubstituteMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:Hekate.Protobuf.Proto.Client.SubstituteMessage)
  return false;
#undef DO_
}

void SubstituteMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:Hekate.Protobuf.Proto.Client.SubstituteMessage)
  // repeated int32 byte_value = 1;
  for (int i = 0; i < this->byte_value_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(
      1, this->byte_value(i), output);
  }

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

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

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

::google::protobuf::uint8* SubstituteMessage::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:Hekate.Protobuf.Proto.Client.SubstituteMessage)
  // repeated int32 byte_value = 1;
  for (int i = 0; i < this->byte_value_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteInt32ToArray(1, this->byte_value(i), target);
  }

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

  // required int32 byte_count = 3;
  if (has_byte_count()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->byte_count(), 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.Client.SubstituteMessage)
  return target;
}

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

  // required int32 byte_count = 3;
  if (has_byte_count()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int32Size(
        this->byte_count());
  }
  // repeated int32 byte_value = 1;
  {
    int data_size = 0;
    for (int i = 0; i < this->byte_value_size(); i++) {
      data_size += ::google::protobuf::internal::WireFormatLite::
        Int32Size(this->byte_value(i));
    }
    total_size += 1 * this->byte_value_size() + data_size;
  }

  // repeated int32 byte_index = 2;
  {
    int data_size = 0;
    for (int i = 0; i < this->byte_index_size(); i++) {
      data_size += ::google::protobuf::internal::WireFormatLite::
        Int32Size(this->byte_index(i));
    }
    total_size += 1 * this->byte_index_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 SubstituteMessage::MergeFrom(const ::google::protobuf::Message& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  const SubstituteMessage* source = 
      ::google::protobuf::internal::DynamicCastToGenerated<const SubstituteMessage>(
          &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void SubstituteMessage::MergeFrom(const SubstituteMessage& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  byte_value_.MergeFrom(from.byte_value_);
  byte_index_.MergeFrom(from.byte_index_);
  if (from._has_bits_[2 / 32] & (0xffu << (2 % 32))) {
    if (from.has_byte_count()) {
      set_byte_count(from.byte_count());
    }
  }
  if (from._internal_metadata_.have_unknown_fields()) {
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
}

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

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

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

  return true;
}

void SubstituteMessage::Swap(SubstituteMessage* other) {
  if (other == this) return;
  InternalSwap(other);
}
void SubstituteMessage::InternalSwap(SubstituteMessage* other) {
  byte_value_.UnsafeArenaSwap(&other->byte_value_);
  byte_index_.UnsafeArenaSwap(&other->byte_index_);
  std::swap(byte_count_, other->byte_count_);
  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 SubstituteMessage::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = SubstituteMessage_descriptor_;
  metadata.reflection = SubstituteMessage_reflection_;
  return metadata;
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// SubstituteMessage

// repeated int32 byte_value = 1;
int SubstituteMessage::byte_value_size() const {
  return byte_value_.size();
}
void SubstituteMessage::clear_byte_value() {
  byte_value_.Clear();
}
 ::google::protobuf::int32 SubstituteMessage::byte_value(int index) const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Client.SubstituteMessage.byte_value)
  return byte_value_.Get(index);
}
 void SubstituteMessage::set_byte_value(int index, ::google::protobuf::int32 value) {
  byte_value_.Set(index, value);
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Client.SubstituteMessage.byte_value)
}
 void SubstituteMessage::add_byte_value(::google::protobuf::int32 value) {
  byte_value_.Add(value);
  // @@protoc_insertion_point(field_add:Hekate.Protobuf.Proto.Client.SubstituteMessage.byte_value)
}
 const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
SubstituteMessage::byte_value() const {
  // @@protoc_insertion_point(field_list:Hekate.Protobuf.Proto.Client.SubstituteMessage.byte_value)
  return byte_value_;
}
 ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
SubstituteMessage::mutable_byte_value() {
  // @@protoc_insertion_point(field_mutable_list:Hekate.Protobuf.Proto.Client.SubstituteMessage.byte_value)
  return &byte_value_;
}

// repeated int32 byte_index = 2;
int SubstituteMessage::byte_index_size() const {
  return byte_index_.size();
}
void SubstituteMessage::clear_byte_index() {
  byte_index_.Clear();
}
 ::google::protobuf::int32 SubstituteMessage::byte_index(int index) const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Client.SubstituteMessage.byte_index)
  return byte_index_.Get(index);
}
 void SubstituteMessage::set_byte_index(int index, ::google::protobuf::int32 value) {
  byte_index_.Set(index, value);
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Client.SubstituteMessage.byte_index)
}
 void SubstituteMessage::add_byte_index(::google::protobuf::int32 value) {
  byte_index_.Add(value);
  // @@protoc_insertion_point(field_add:Hekate.Protobuf.Proto.Client.SubstituteMessage.byte_index)
}
 const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
SubstituteMessage::byte_index() const {
  // @@protoc_insertion_point(field_list:Hekate.Protobuf.Proto.Client.SubstituteMessage.byte_index)
  return byte_index_;
}
 ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
SubstituteMessage::mutable_byte_index() {
  // @@protoc_insertion_point(field_mutable_list:Hekate.Protobuf.Proto.Client.SubstituteMessage.byte_index)
  return &byte_index_;
}

// required int32 byte_count = 3;
bool SubstituteMessage::has_byte_count() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
void SubstituteMessage::set_has_byte_count() {
  _has_bits_[0] |= 0x00000004u;
}
void SubstituteMessage::clear_has_byte_count() {
  _has_bits_[0] &= ~0x00000004u;
}
void SubstituteMessage::clear_byte_count() {
  byte_count_ = 0;
  clear_has_byte_count();
}
 ::google::protobuf::int32 SubstituteMessage::byte_count() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Client.SubstituteMessage.byte_count)
  return byte_count_;
}
 void SubstituteMessage::set_byte_count(::google::protobuf::int32 value) {
  set_has_byte_count();
  byte_count_ = value;
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Client.SubstituteMessage.byte_count)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#ifndef _MSC_VER
const int ReplacementMessage::kBufferFieldNumber;
const int ReplacementMessage::kLengthFieldNumber;
#endif  // !_MSC_VER

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

void ReplacementMessage::InitAsDefaultInstance() {
}

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

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

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

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

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

const ReplacementMessage& ReplacementMessage::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_HekateClientProto_2eproto();
  return *default_instance_;
}

ReplacementMessage* ReplacementMessage::default_instance_ = NULL;

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

void ReplacementMessage::Clear() {
  if (_has_bits_[0 / 32] & 3u) {
    if (has_buffer()) {
      buffer_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    }
    length_ = 0;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  if (_internal_metadata_.have_unknown_fields()) {
    mutable_unknown_fields()->Clear();
  }
}

bool ReplacementMessage::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.Client.ReplacementMessage)
  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 bytes buffer = 1;
      case 1: {
        if (tag == 10) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_buffer()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_length;
        break;
      }

      // required int32 length = 2;
      case 2: {
        if (tag == 16) {
         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->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.Client.ReplacementMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:Hekate.Protobuf.Proto.Client.ReplacementMessage)
  return false;
#undef DO_
}

void ReplacementMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:Hekate.Protobuf.Proto.Client.ReplacementMessage)
  // required bytes buffer = 1;
  if (has_buffer()) {
    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
      1, this->buffer(), output);
  }

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

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

::google::protobuf::uint8* ReplacementMessage::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:Hekate.Protobuf.Proto.Client.ReplacementMessage)
  // required bytes buffer = 1;
  if (has_buffer()) {
    target =
      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
        1, this->buffer(), target);
  }

  // required int32 length = 2;
  if (has_length()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->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.Client.ReplacementMessage)
  return target;
}

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

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

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

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

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

    // required int32 length = 2;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int32Size(
        this->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 ReplacementMessage::MergeFrom(const ::google::protobuf::Message& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  const ReplacementMessage* source = 
      ::google::protobuf::internal::DynamicCastToGenerated<const ReplacementMessage>(
          &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void ReplacementMessage::MergeFrom(const ReplacementMessage& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    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._internal_metadata_.have_unknown_fields()) {
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
}

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

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

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

  return true;
}

void ReplacementMessage::Swap(ReplacementMessage* other) {
  if (other == this) return;
  InternalSwap(other);
}
void ReplacementMessage::InternalSwap(ReplacementMessage* other) {
  buffer_.Swap(&other->buffer_);
  std::swap(length_, other->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 ReplacementMessage::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = ReplacementMessage_descriptor_;
  metadata.reflection = ReplacementMessage_reflection_;
  return metadata;
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// ReplacementMessage

// required bytes buffer = 1;
bool ReplacementMessage::has_buffer() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void ReplacementMessage::set_has_buffer() {
  _has_bits_[0] |= 0x00000001u;
}
void ReplacementMessage::clear_has_buffer() {
  _has_bits_[0] &= ~0x00000001u;
}
void ReplacementMessage::clear_buffer() {
  buffer_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_buffer();
}
 const ::std::string& ReplacementMessage::buffer() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Client.ReplacementMessage.buffer)
  return buffer_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
 void ReplacementMessage::set_buffer(const ::std::string& value) {
  set_has_buffer();
  buffer_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Client.ReplacementMessage.buffer)
}
 void ReplacementMessage::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.Client.ReplacementMessage.buffer)
}
 void ReplacementMessage::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.Client.ReplacementMessage.buffer)
}
 ::std::string* ReplacementMessage::mutable_buffer() {
  set_has_buffer();
  // @@protoc_insertion_point(field_mutable:Hekate.Protobuf.Proto.Client.ReplacementMessage.buffer)
  return buffer_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
 ::std::string* ReplacementMessage::release_buffer() {
  clear_has_buffer();
  return buffer_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
 void ReplacementMessage::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.Client.ReplacementMessage.buffer)
}

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

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#ifndef _MSC_VER
const int AddFilterMessage::kTypeFieldNumber;
const int AddFilterMessage::kFilterIdFieldNumber;
const int AddFilterMessage::kBreakOnHitFieldNumber;
const int AddFilterMessage::kByteFilterFieldNumber;
const int AddFilterMessage::kLengthFilterFieldNumber;
const int AddFilterMessage::kStringFilterFieldNumber;
const int AddFilterMessage::kSubstituteFieldNumber;
const int AddFilterMessage::kReplacementFieldNumber;
#endif  // !_MSC_VER

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

void AddFilterMessage::InitAsDefaultInstance() {
  byte_filter_ = const_cast< ::Hekate::Protobuf::Proto::Client::ByteFilterMessage*>(&::Hekate::Protobuf::Proto::Client::ByteFilterMessage::default_instance());
  length_filter_ = const_cast< ::Hekate::Protobuf::Proto::Client::LengthFilterMessage*>(&::Hekate::Protobuf::Proto::Client::LengthFilterMessage::default_instance());
  string_filter_ = const_cast< ::Hekate::Protobuf::Proto::Client::SubstringFilterMessage*>(&::Hekate::Protobuf::Proto::Client::SubstringFilterMessage::default_instance());
  substitute_ = const_cast< ::Hekate::Protobuf::Proto::Client::SubstituteMessage*>(&::Hekate::Protobuf::Proto::Client::SubstituteMessage::default_instance());
  replacement_ = const_cast< ::Hekate::Protobuf::Proto::Client::ReplacementMessage*>(&::Hekate::Protobuf::Proto::Client::ReplacementMessage::default_instance());
}

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

void AddFilterMessage::SharedCtor() {
  _cached_size_ = 0;
  type_ = 0;
  filter_id_ = 0;
  break_on_hit_ = false;
  byte_filter_ = NULL;
  length_filter_ = NULL;
  string_filter_ = NULL;
  substitute_ = NULL;
  replacement_ = NULL;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

void AddFilterMessage::SharedDtor() {
  if (this != default_instance_) {
    delete byte_filter_;
    delete length_filter_;
    delete string_filter_;
    delete substitute_;
    delete replacement_;
  }
}

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

const AddFilterMessage& AddFilterMessage::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_HekateClientProto_2eproto();
  return *default_instance_;
}

AddFilterMessage* AddFilterMessage::default_instance_ = NULL;

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

void AddFilterMessage::Clear() {
#define ZR_HELPER_(f) reinterpret_cast<char*>(\
  &reinterpret_cast<AddFilterMessage*>(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] & 255u) {
    ZR_(type_, filter_id_);
    break_on_hit_ = false;
    if (has_byte_filter()) {
      if (byte_filter_ != NULL) byte_filter_->::Hekate::Protobuf::Proto::Client::ByteFilterMessage::Clear();
    }
    if (has_length_filter()) {
      if (length_filter_ != NULL) length_filter_->::Hekate::Protobuf::Proto::Client::LengthFilterMessage::Clear();
    }
    if (has_string_filter()) {
      if (string_filter_ != NULL) string_filter_->::Hekate::Protobuf::Proto::Client::SubstringFilterMessage::Clear();
    }
    if (has_substitute()) {
      if (substitute_ != NULL) substitute_->::Hekate::Protobuf::Proto::Client::SubstituteMessage::Clear();
    }
    if (has_replacement()) {
      if (replacement_ != NULL) replacement_->::Hekate::Protobuf::Proto::Client::ReplacementMessage::Clear();
    }
  }

#undef ZR_HELPER_
#undef ZR_

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

bool AddFilterMessage::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.Client.AddFilterMessage)
  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.Client.FilterType type = 1;
      case 1: {
        if (tag == 8) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::Hekate::Protobuf::Proto::Client::FilterType_IsValid(value)) {
            set_type(static_cast< ::Hekate::Protobuf::Proto::Client::FilterType >(value));
          } else {
            mutable_unknown_fields()->AddVarint(1, value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_filter_id;
        break;
      }

      // required int32 filter_id = 2;
      case 2: {
        if (tag == 16) {
         parse_filter_id:
          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(24)) goto parse_break_on_hit;
        break;
      }

      // required bool break_on_hit = 3;
      case 3: {
        if (tag == 24) {
         parse_break_on_hit:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &break_on_hit_)));
          set_has_break_on_hit();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(34)) goto parse_byte_filter;
        break;
      }

      // optional .Hekate.Protobuf.Proto.Client.ByteFilterMessage byte_filter = 4;
      case 4: {
        if (tag == 34) {
         parse_byte_filter:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_byte_filter()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(42)) goto parse_length_filter;
        break;
      }

      // optional .Hekate.Protobuf.Proto.Client.LengthFilterMessage length_filter = 5;
      case 5: {
        if (tag == 42) {
         parse_length_filter:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_length_filter()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(50)) goto parse_string_filter;
        break;
      }

      // optional .Hekate.Protobuf.Proto.Client.SubstringFilterMessage string_filter = 6;
      case 6: {
        if (tag == 50) {
         parse_string_filter:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_string_filter()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(58)) goto parse_substitute;
        break;
      }

      // optional .Hekate.Protobuf.Proto.Client.SubstituteMessage substitute = 7;
      case 7: {
        if (tag == 58) {
         parse_substitute:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_substitute()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(66)) goto parse_replacement;
        break;
      }

      // optional .Hekate.Protobuf.Proto.Client.ReplacementMessage replacement = 8;
      case 8: {
        if (tag == 66) {
         parse_replacement:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_replacement()));
        } 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.Client.AddFilterMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:Hekate.Protobuf.Proto.Client.AddFilterMessage)
  return false;
#undef DO_
}

void AddFilterMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:Hekate.Protobuf.Proto.Client.AddFilterMessage)
  // required .Hekate.Protobuf.Proto.Client.FilterType type = 1;
  if (has_type()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->type(), output);
  }

  // required int32 filter_id = 2;
  if (has_filter_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->filter_id(), output);
  }

  // required bool break_on_hit = 3;
  if (has_break_on_hit()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->break_on_hit(), output);
  }

  // optional .Hekate.Protobuf.Proto.Client.ByteFilterMessage byte_filter = 4;
  if (has_byte_filter()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      4, *this->byte_filter_, output);
  }

  // optional .Hekate.Protobuf.Proto.Client.LengthFilterMessage length_filter = 5;
  if (has_length_filter()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      5, *this->length_filter_, output);
  }

  // optional .Hekate.Protobuf.Proto.Client.SubstringFilterMessage string_filter = 6;
  if (has_string_filter()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      6, *this->string_filter_, output);
  }

  // optional .Hekate.Protobuf.Proto.Client.SubstituteMessage substitute = 7;
  if (has_substitute()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      7, *this->substitute_, output);
  }

  // optional .Hekate.Protobuf.Proto.Client.ReplacementMessage replacement = 8;
  if (has_replacement()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      8, *this->replacement_, output);
  }

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

::google::protobuf::uint8* AddFilterMessage::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:Hekate.Protobuf.Proto.Client.AddFilterMessage)
  // required .Hekate.Protobuf.Proto.Client.FilterType type = 1;
  if (has_type()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->type(), target);
  }

  // required int32 filter_id = 2;
  if (has_filter_id()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->filter_id(), target);
  }

  // required bool break_on_hit = 3;
  if (has_break_on_hit()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->break_on_hit(), target);
  }

  // optional .Hekate.Protobuf.Proto.Client.ByteFilterMessage byte_filter = 4;
  if (has_byte_filter()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        4, *this->byte_filter_, target);
  }

  // optional .Hekate.Protobuf.Proto.Client.LengthFilterMessage length_filter = 5;
  if (has_length_filter()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        5, *this->length_filter_, target);
  }

  // optional .Hekate.Protobuf.Proto.Client.SubstringFilterMessage string_filter = 6;
  if (has_string_filter()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        6, *this->string_filter_, target);
  }

  // optional .Hekate.Protobuf.Proto.Client.SubstituteMessage substitute = 7;
  if (has_substitute()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        7, *this->substitute_, target);
  }

  // optional .Hekate.Protobuf.Proto.Client.ReplacementMessage replacement = 8;
  if (has_replacement()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        8, *this->replacement_, 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.Client.AddFilterMessage)
  return target;
}

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

  if (has_type()) {
    // required .Hekate.Protobuf.Proto.Client.FilterType type = 1;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::EnumSize(this->type());
  }

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

  if (has_break_on_hit()) {
    // required bool break_on_hit = 3;
    total_size += 1 + 1;
  }

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

  if (((_has_bits_[0] & 0x00000007) ^ 0x00000007) == 0) {  // All required fields are present.
    // required .Hekate.Protobuf.Proto.Client.FilterType type = 1;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::EnumSize(this->type());

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

    // required bool break_on_hit = 3;
    total_size += 1 + 1;

  } else {
    total_size += RequiredFieldsByteSizeFallback();
  }
  if (_has_bits_[3 / 32] & 248) {
    // optional .Hekate.Protobuf.Proto.Client.ByteFilterMessage byte_filter = 4;
    if (has_byte_filter()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *this->byte_filter_);
    }

    // optional .Hekate.Protobuf.Proto.Client.LengthFilterMessage length_filter = 5;
    if (has_length_filter()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *this->length_filter_);
    }

    // optional .Hekate.Protobuf.Proto.Client.SubstringFilterMessage string_filter = 6;
    if (has_string_filter()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *this->string_filter_);
    }

    // optional .Hekate.Protobuf.Proto.Client.SubstituteMessage substitute = 7;
    if (has_substitute()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *this->substitute_);
    }

    // optional .Hekate.Protobuf.Proto.Client.ReplacementMessage replacement = 8;
    if (has_replacement()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *this->replacement_);
    }

  }
  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 AddFilterMessage::MergeFrom(const ::google::protobuf::Message& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  const AddFilterMessage* source = 
      ::google::protobuf::internal::DynamicCastToGenerated<const AddFilterMessage>(
          &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void AddFilterMessage::MergeFrom(const AddFilterMessage& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_type()) {
      set_type(from.type());
    }
    if (from.has_filter_id()) {
      set_filter_id(from.filter_id());
    }
    if (from.has_break_on_hit()) {
      set_break_on_hit(from.break_on_hit());
    }
    if (from.has_byte_filter()) {
      mutable_byte_filter()->::Hekate::Protobuf::Proto::Client::ByteFilterMessage::MergeFrom(from.byte_filter());
    }
    if (from.has_length_filter()) {
      mutable_length_filter()->::Hekate::Protobuf::Proto::Client::LengthFilterMessage::MergeFrom(from.length_filter());
    }
    if (from.has_string_filter()) {
      mutable_string_filter()->::Hekate::Protobuf::Proto::Client::SubstringFilterMessage::MergeFrom(from.string_filter());
    }
    if (from.has_substitute()) {
      mutable_substitute()->::Hekate::Protobuf::Proto::Client::SubstituteMessage::MergeFrom(from.substitute());
    }
    if (from.has_replacement()) {
      mutable_replacement()->::Hekate::Protobuf::Proto::Client::ReplacementMessage::MergeFrom(from.replacement());
    }
  }
  if (from._internal_metadata_.have_unknown_fields()) {
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
}

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

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

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

  if (has_byte_filter()) {
    if (!this->byte_filter_->IsInitialized()) return false;
  }
  if (has_length_filter()) {
    if (!this->length_filter_->IsInitialized()) return false;
  }
  if (has_string_filter()) {
    if (!this->string_filter_->IsInitialized()) return false;
  }
  if (has_substitute()) {
    if (!this->substitute_->IsInitialized()) return false;
  }
  if (has_replacement()) {
    if (!this->replacement_->IsInitialized()) return false;
  }
  return true;
}

void AddFilterMessage::Swap(AddFilterMessage* other) {
  if (other == this) return;
  InternalSwap(other);
}
void AddFilterMessage::InternalSwap(AddFilterMessage* other) {
  std::swap(type_, other->type_);
  std::swap(filter_id_, other->filter_id_);
  std::swap(break_on_hit_, other->break_on_hit_);
  std::swap(byte_filter_, other->byte_filter_);
  std::swap(length_filter_, other->length_filter_);
  std::swap(string_filter_, other->string_filter_);
  std::swap(substitute_, other->substitute_);
  std::swap(replacement_, other->replacement_);
  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 AddFilterMessage::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = AddFilterMessage_descriptor_;
  metadata.reflection = AddFilterMessage_reflection_;
  return metadata;
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// AddFilterMessage

// required .Hekate.Protobuf.Proto.Client.FilterType type = 1;
bool AddFilterMessage::has_type() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void AddFilterMessage::set_has_type() {
  _has_bits_[0] |= 0x00000001u;
}
void AddFilterMessage::clear_has_type() {
  _has_bits_[0] &= ~0x00000001u;
}
void AddFilterMessage::clear_type() {
  type_ = 0;
  clear_has_type();
}
 ::Hekate::Protobuf::Proto::Client::FilterType AddFilterMessage::type() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Client.AddFilterMessage.type)
  return static_cast< ::Hekate::Protobuf::Proto::Client::FilterType >(type_);
}
 void AddFilterMessage::set_type(::Hekate::Protobuf::Proto::Client::FilterType value) {
  assert(::Hekate::Protobuf::Proto::Client::FilterType_IsValid(value));
  set_has_type();
  type_ = value;
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Client.AddFilterMessage.type)
}

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

// required bool break_on_hit = 3;
bool AddFilterMessage::has_break_on_hit() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
void AddFilterMessage::set_has_break_on_hit() {
  _has_bits_[0] |= 0x00000004u;
}
void AddFilterMessage::clear_has_break_on_hit() {
  _has_bits_[0] &= ~0x00000004u;
}
void AddFilterMessage::clear_break_on_hit() {
  break_on_hit_ = false;
  clear_has_break_on_hit();
}
 bool AddFilterMessage::break_on_hit() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Client.AddFilterMessage.break_on_hit)
  return break_on_hit_;
}
 void AddFilterMessage::set_break_on_hit(bool value) {
  set_has_break_on_hit();
  break_on_hit_ = value;
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Client.AddFilterMessage.break_on_hit)
}

// optional .Hekate.Protobuf.Proto.Client.ByteFilterMessage byte_filter = 4;
bool AddFilterMessage::has_byte_filter() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
void AddFilterMessage::set_has_byte_filter() {
  _has_bits_[0] |= 0x00000008u;
}
void AddFilterMessage::clear_has_byte_filter() {
  _has_bits_[0] &= ~0x00000008u;
}
void AddFilterMessage::clear_byte_filter() {
  if (byte_filter_ != NULL) byte_filter_->::Hekate::Protobuf::Proto::Client::ByteFilterMessage::Clear();
  clear_has_byte_filter();
}
 const ::Hekate::Protobuf::Proto::Client::ByteFilterMessage& AddFilterMessage::byte_filter() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Client.AddFilterMessage.byte_filter)
  return byte_filter_ != NULL ? *byte_filter_ : *default_instance_->byte_filter_;
}
 ::Hekate::Protobuf::Proto::Client::ByteFilterMessage* AddFilterMessage::mutable_byte_filter() {
  set_has_byte_filter();
  if (byte_filter_ == NULL) {
    byte_filter_ = new ::Hekate::Protobuf::Proto::Client::ByteFilterMessage;
  }
  // @@protoc_insertion_point(field_mutable:Hekate.Protobuf.Proto.Client.AddFilterMessage.byte_filter)
  return byte_filter_;
}
 ::Hekate::Protobuf::Proto::Client::ByteFilterMessage* AddFilterMessage::release_byte_filter() {
  clear_has_byte_filter();
  ::Hekate::Protobuf::Proto::Client::ByteFilterMessage* temp = byte_filter_;
  byte_filter_ = NULL;
  return temp;
}
 void AddFilterMessage::set_allocated_byte_filter(::Hekate::Protobuf::Proto::Client::ByteFilterMessage* byte_filter) {
  delete byte_filter_;
  byte_filter_ = byte_filter;
  if (byte_filter) {
    set_has_byte_filter();
  } else {
    clear_has_byte_filter();
  }
  // @@protoc_insertion_point(field_set_allocated:Hekate.Protobuf.Proto.Client.AddFilterMessage.byte_filter)
}

// optional .Hekate.Protobuf.Proto.Client.LengthFilterMessage length_filter = 5;
bool AddFilterMessage::has_length_filter() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
void AddFilterMessage::set_has_length_filter() {
  _has_bits_[0] |= 0x00000010u;
}
void AddFilterMessage::clear_has_length_filter() {
  _has_bits_[0] &= ~0x00000010u;
}
void AddFilterMessage::clear_length_filter() {
  if (length_filter_ != NULL) length_filter_->::Hekate::Protobuf::Proto::Client::LengthFilterMessage::Clear();
  clear_has_length_filter();
}
 const ::Hekate::Protobuf::Proto::Client::LengthFilterMessage& AddFilterMessage::length_filter() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Client.AddFilterMessage.length_filter)
  return length_filter_ != NULL ? *length_filter_ : *default_instance_->length_filter_;
}
 ::Hekate::Protobuf::Proto::Client::LengthFilterMessage* AddFilterMessage::mutable_length_filter() {
  set_has_length_filter();
  if (length_filter_ == NULL) {
    length_filter_ = new ::Hekate::Protobuf::Proto::Client::LengthFilterMessage;
  }
  // @@protoc_insertion_point(field_mutable:Hekate.Protobuf.Proto.Client.AddFilterMessage.length_filter)
  return length_filter_;
}
 ::Hekate::Protobuf::Proto::Client::LengthFilterMessage* AddFilterMessage::release_length_filter() {
  clear_has_length_filter();
  ::Hekate::Protobuf::Proto::Client::LengthFilterMessage* temp = length_filter_;
  length_filter_ = NULL;
  return temp;
}
 void AddFilterMessage::set_allocated_length_filter(::Hekate::Protobuf::Proto::Client::LengthFilterMessage* length_filter) {
  delete length_filter_;
  length_filter_ = length_filter;
  if (length_filter) {
    set_has_length_filter();
  } else {
    clear_has_length_filter();
  }
  // @@protoc_insertion_point(field_set_allocated:Hekate.Protobuf.Proto.Client.AddFilterMessage.length_filter)
}

// optional .Hekate.Protobuf.Proto.Client.SubstringFilterMessage string_filter = 6;
bool AddFilterMessage::has_string_filter() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
void AddFilterMessage::set_has_string_filter() {
  _has_bits_[0] |= 0x00000020u;
}
void AddFilterMessage::clear_has_string_filter() {
  _has_bits_[0] &= ~0x00000020u;
}
void AddFilterMessage::clear_string_filter() {
  if (string_filter_ != NULL) string_filter_->::Hekate::Protobuf::Proto::Client::SubstringFilterMessage::Clear();
  clear_has_string_filter();
}
 const ::Hekate::Protobuf::Proto::Client::SubstringFilterMessage& AddFilterMessage::string_filter() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Client.AddFilterMessage.string_filter)
  return string_filter_ != NULL ? *string_filter_ : *default_instance_->string_filter_;
}
 ::Hekate::Protobuf::Proto::Client::SubstringFilterMessage* AddFilterMessage::mutable_string_filter() {
  set_has_string_filter();
  if (string_filter_ == NULL) {
    string_filter_ = new ::Hekate::Protobuf::Proto::Client::SubstringFilterMessage;
  }
  // @@protoc_insertion_point(field_mutable:Hekate.Protobuf.Proto.Client.AddFilterMessage.string_filter)
  return string_filter_;
}
 ::Hekate::Protobuf::Proto::Client::SubstringFilterMessage* AddFilterMessage::release_string_filter() {
  clear_has_string_filter();
  ::Hekate::Protobuf::Proto::Client::SubstringFilterMessage* temp = string_filter_;
  string_filter_ = NULL;
  return temp;
}
 void AddFilterMessage::set_allocated_string_filter(::Hekate::Protobuf::Proto::Client::SubstringFilterMessage* string_filter) {
  delete string_filter_;
  string_filter_ = string_filter;
  if (string_filter) {
    set_has_string_filter();
  } else {
    clear_has_string_filter();
  }
  // @@protoc_insertion_point(field_set_allocated:Hekate.Protobuf.Proto.Client.AddFilterMessage.string_filter)
}

// optional .Hekate.Protobuf.Proto.Client.SubstituteMessage substitute = 7;
bool AddFilterMessage::has_substitute() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
void AddFilterMessage::set_has_substitute() {
  _has_bits_[0] |= 0x00000040u;
}
void AddFilterMessage::clear_has_substitute() {
  _has_bits_[0] &= ~0x00000040u;
}
void AddFilterMessage::clear_substitute() {
  if (substitute_ != NULL) substitute_->::Hekate::Protobuf::Proto::Client::SubstituteMessage::Clear();
  clear_has_substitute();
}
 const ::Hekate::Protobuf::Proto::Client::SubstituteMessage& AddFilterMessage::substitute() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Client.AddFilterMessage.substitute)
  return substitute_ != NULL ? *substitute_ : *default_instance_->substitute_;
}
 ::Hekate::Protobuf::Proto::Client::SubstituteMessage* AddFilterMessage::mutable_substitute() {
  set_has_substitute();
  if (substitute_ == NULL) {
    substitute_ = new ::Hekate::Protobuf::Proto::Client::SubstituteMessage;
  }
  // @@protoc_insertion_point(field_mutable:Hekate.Protobuf.Proto.Client.AddFilterMessage.substitute)
  return substitute_;
}
 ::Hekate::Protobuf::Proto::Client::SubstituteMessage* AddFilterMessage::release_substitute() {
  clear_has_substitute();
  ::Hekate::Protobuf::Proto::Client::SubstituteMessage* temp = substitute_;
  substitute_ = NULL;
  return temp;
}
 void AddFilterMessage::set_allocated_substitute(::Hekate::Protobuf::Proto::Client::SubstituteMessage* substitute) {
  delete substitute_;
  substitute_ = substitute;
  if (substitute) {
    set_has_substitute();
  } else {
    clear_has_substitute();
  }
  // @@protoc_insertion_point(field_set_allocated:Hekate.Protobuf.Proto.Client.AddFilterMessage.substitute)
}

// optional .Hekate.Protobuf.Proto.Client.ReplacementMessage replacement = 8;
bool AddFilterMessage::has_replacement() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
void AddFilterMessage::set_has_replacement() {
  _has_bits_[0] |= 0x00000080u;
}
void AddFilterMessage::clear_has_replacement() {
  _has_bits_[0] &= ~0x00000080u;
}
void AddFilterMessage::clear_replacement() {
  if (replacement_ != NULL) replacement_->::Hekate::Protobuf::Proto::Client::ReplacementMessage::Clear();
  clear_has_replacement();
}
 const ::Hekate::Protobuf::Proto::Client::ReplacementMessage& AddFilterMessage::replacement() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Client.AddFilterMessage.replacement)
  return replacement_ != NULL ? *replacement_ : *default_instance_->replacement_;
}
 ::Hekate::Protobuf::Proto::Client::ReplacementMessage* AddFilterMessage::mutable_replacement() {
  set_has_replacement();
  if (replacement_ == NULL) {
    replacement_ = new ::Hekate::Protobuf::Proto::Client::ReplacementMessage;
  }
  // @@protoc_insertion_point(field_mutable:Hekate.Protobuf.Proto.Client.AddFilterMessage.replacement)
  return replacement_;
}
 ::Hekate::Protobuf::Proto::Client::ReplacementMessage* AddFilterMessage::release_replacement() {
  clear_has_replacement();
  ::Hekate::Protobuf::Proto::Client::ReplacementMessage* temp = replacement_;
  replacement_ = NULL;
  return temp;
}
 void AddFilterMessage::set_allocated_replacement(::Hekate::Protobuf::Proto::Client::ReplacementMessage* replacement) {
  delete replacement_;
  replacement_ = replacement;
  if (replacement) {
    set_has_replacement();
  } else {
    clear_has_replacement();
  }
  // @@protoc_insertion_point(field_set_allocated:Hekate.Protobuf.Proto.Client.AddFilterMessage.replacement)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#ifndef _MSC_VER
const int RemoveFilterMessage::kFilterIdFieldNumber;
#endif  // !_MSC_VER

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

void RemoveFilterMessage::InitAsDefaultInstance() {
}

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

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

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

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

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

const RemoveFilterMessage& RemoveFilterMessage::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_HekateClientProto_2eproto();
  return *default_instance_;
}

RemoveFilterMessage* RemoveFilterMessage::default_instance_ = NULL;

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

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

bool RemoveFilterMessage::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.Client.RemoveFilterMessage)
  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->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.Client.RemoveFilterMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:Hekate.Protobuf.Proto.Client.RemoveFilterMessage)
  return false;
#undef DO_
}

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

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

::google::protobuf::uint8* RemoveFilterMessage::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:Hekate.Protobuf.Proto.Client.RemoveFilterMessage)
  // required int32 filter_id = 1;
  if (has_filter_id()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->filter_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.Client.RemoveFilterMessage)
  return target;
}

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

  // required int32 filter_id = 1;
  if (has_filter_id()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int32Size(
        this->filter_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 RemoveFilterMessage::MergeFrom(const ::google::protobuf::Message& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  const RemoveFilterMessage* source = 
      ::google::protobuf::internal::DynamicCastToGenerated<const RemoveFilterMessage>(
          &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void RemoveFilterMessage::MergeFrom(const RemoveFilterMessage& 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._internal_metadata_.have_unknown_fields()) {
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
}

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

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

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

  return true;
}

void RemoveFilterMessage::Swap(RemoveFilterMessage* other) {
  if (other == this) return;
  InternalSwap(other);
}
void RemoveFilterMessage::InternalSwap(RemoveFilterMessage* other) {
  std::swap(filter_id_, other->filter_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 RemoveFilterMessage::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = RemoveFilterMessage_descriptor_;
  metadata.reflection = RemoveFilterMessage_reflection_;
  return metadata;
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// RemoveFilterMessage

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

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#ifndef _MSC_VER
const int ReplayMessage::kMessageFieldNumber;
#endif  // !_MSC_VER

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

void ReplayMessage::InitAsDefaultInstance() {
  message_ = const_cast< ::Hekate::Protobuf::Proto::Server::HekateToClientMessage*>(&::Hekate::Protobuf::Proto::Server::HekateToClientMessage::default_instance());
}

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

void ReplayMessage::SharedCtor() {
  _cached_size_ = 0;
  message_ = NULL;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

void ReplayMessage::SharedDtor() {
  if (this != default_instance_) {
    delete message_;
  }
}

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

const ReplayMessage& ReplayMessage::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_HekateClientProto_2eproto();
  return *default_instance_;
}

ReplayMessage* ReplayMessage::default_instance_ = NULL;

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

void ReplayMessage::Clear() {
  if (has_message()) {
    if (message_ != NULL) message_->::Hekate::Protobuf::Proto::Server::HekateToClientMessage::Clear();
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  if (_internal_metadata_.have_unknown_fields()) {
    mutable_unknown_fields()->Clear();
  }
}

bool ReplayMessage::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.Client.ReplayMessage)
  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 message = 1;
      case 1: {
        if (tag == 10) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_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.Client.ReplayMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:Hekate.Protobuf.Proto.Client.ReplayMessage)
  return false;
#undef DO_
}

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

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

::google::protobuf::uint8* ReplayMessage::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:Hekate.Protobuf.Proto.Client.ReplayMessage)
  // required .Hekate.Protobuf.Proto.Server.HekateToClientMessage message = 1;
  if (has_message()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, *this->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.Client.ReplayMessage)
  return target;
}

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

  // required .Hekate.Protobuf.Proto.Server.HekateToClientMessage message = 1;
  if (has_message()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        *this->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 ReplayMessage::MergeFrom(const ::google::protobuf::Message& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  const ReplayMessage* source = 
      ::google::protobuf::internal::DynamicCastToGenerated<const ReplayMessage>(
          &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void ReplayMessage::MergeFrom(const ReplayMessage& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_message()) {
      mutable_message()->::Hekate::Protobuf::Proto::Server::HekateToClientMessage::MergeFrom(from.message());
    }
  }
  if (from._internal_metadata_.have_unknown_fields()) {
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
}

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

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

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

  if (has_message()) {
    if (!this->message_->IsInitialized()) return false;
  }
  return true;
}

void ReplayMessage::Swap(ReplayMessage* other) {
  if (other == this) return;
  InternalSwap(other);
}
void ReplayMessage::InternalSwap(ReplayMessage* other) {
  std::swap(message_, other->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 ReplayMessage::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = ReplayMessage_descriptor_;
  metadata.reflection = ReplayMessage_reflection_;
  return metadata;
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// ReplayMessage

// required .Hekate.Protobuf.Proto.Server.HekateToClientMessage message = 1;
bool ReplayMessage::has_message() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void ReplayMessage::set_has_message() {
  _has_bits_[0] |= 0x00000001u;
}
void ReplayMessage::clear_has_message() {
  _has_bits_[0] &= ~0x00000001u;
}
void ReplayMessage::clear_message() {
  if (message_ != NULL) message_->::Hekate::Protobuf::Proto::Server::HekateToClientMessage::Clear();
  clear_has_message();
}
 const ::Hekate::Protobuf::Proto::Server::HekateToClientMessage& ReplayMessage::message() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Client.ReplayMessage.message)
  return message_ != NULL ? *message_ : *default_instance_->message_;
}
 ::Hekate::Protobuf::Proto::Server::HekateToClientMessage* ReplayMessage::mutable_message() {
  set_has_message();
  if (message_ == NULL) {
    message_ = new ::Hekate::Protobuf::Proto::Server::HekateToClientMessage;
  }
  // @@protoc_insertion_point(field_mutable:Hekate.Protobuf.Proto.Client.ReplayMessage.message)
  return message_;
}
 ::Hekate::Protobuf::Proto::Server::HekateToClientMessage* ReplayMessage::release_message() {
  clear_has_message();
  ::Hekate::Protobuf::Proto::Server::HekateToClientMessage* temp = message_;
  message_ = NULL;
  return temp;
}
 void ReplayMessage::set_allocated_message(::Hekate::Protobuf::Proto::Server::HekateToClientMessage* message) {
  delete message_;
  message_ = message;
  if (message) {
    set_has_message();
  } else {
    clear_has_message();
  }
  // @@protoc_insertion_point(field_set_allocated:Hekate.Protobuf.Proto.Client.ReplayMessage.message)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#ifndef _MSC_VER
const int ClientToHekateMessage::kTypeFieldNumber;
const int ClientToHekateMessage::kAddHookFieldNumber;
const int ClientToHekateMessage::kRemoveHookFieldNumber;
const int ClientToHekateMessage::kAddFilterFieldNumber;
const int ClientToHekateMessage::kRemoveFilterFieldNumber;
const int ClientToHekateMessage::kReplayFieldNumber;
const int ClientToHekateMessage::kContinueFieldNumber;
#endif  // !_MSC_VER

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

void ClientToHekateMessage::InitAsDefaultInstance() {
  add_hook_ = const_cast< ::Hekate::Protobuf::Proto::Client::AddHookMessage*>(&::Hekate::Protobuf::Proto::Client::AddHookMessage::default_instance());
  remove_hook_ = const_cast< ::Hekate::Protobuf::Proto::Client::RemoveHookMessage*>(&::Hekate::Protobuf::Proto::Client::RemoveHookMessage::default_instance());
  add_filter_ = const_cast< ::Hekate::Protobuf::Proto::Client::AddFilterMessage*>(&::Hekate::Protobuf::Proto::Client::AddFilterMessage::default_instance());
  remove_filter_ = const_cast< ::Hekate::Protobuf::Proto::Client::RemoveFilterMessage*>(&::Hekate::Protobuf::Proto::Client::RemoveFilterMessage::default_instance());
  replay_ = const_cast< ::Hekate::Protobuf::Proto::Client::ReplayMessage*>(&::Hekate::Protobuf::Proto::Client::ReplayMessage::default_instance());
}

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

void ClientToHekateMessage::SharedCtor() {
  _cached_size_ = 0;
  type_ = 0;
  add_hook_ = NULL;
  remove_hook_ = NULL;
  add_filter_ = NULL;
  remove_filter_ = NULL;
  replay_ = NULL;
  continue__ = false;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

void ClientToHekateMessage::SharedDtor() {
  if (this != default_instance_) {
    delete add_hook_;
    delete remove_hook_;
    delete add_filter_;
    delete remove_filter_;
    delete replay_;
  }
}

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

const ClientToHekateMessage& ClientToHekateMessage::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_HekateClientProto_2eproto();
  return *default_instance_;
}

ClientToHekateMessage* ClientToHekateMessage::default_instance_ = NULL;

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

void ClientToHekateMessage::Clear() {
#define ZR_HELPER_(f) reinterpret_cast<char*>(\
  &reinterpret_cast<ClientToHekateMessage*>(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] & 127u) {
    ZR_(type_, continue__);
    if (has_add_hook()) {
      if (add_hook_ != NULL) add_hook_->::Hekate::Protobuf::Proto::Client::AddHookMessage::Clear();
    }
    if (has_remove_hook()) {
      if (remove_hook_ != NULL) remove_hook_->::Hekate::Protobuf::Proto::Client::RemoveHookMessage::Clear();
    }
    if (has_add_filter()) {
      if (add_filter_ != NULL) add_filter_->::Hekate::Protobuf::Proto::Client::AddFilterMessage::Clear();
    }
    if (has_remove_filter()) {
      if (remove_filter_ != NULL) remove_filter_->::Hekate::Protobuf::Proto::Client::RemoveFilterMessage::Clear();
    }
    if (has_replay()) {
      if (replay_ != NULL) replay_->::Hekate::Protobuf::Proto::Client::ReplayMessage::Clear();
    }
  }

#undef ZR_HELPER_
#undef ZR_

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

bool ClientToHekateMessage::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.Client.ClientToHekateMessage)
  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.Client.MessageType type = 1;
      case 1: {
        if (tag == 8) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::Hekate::Protobuf::Proto::Client::MessageType_IsValid(value)) {
            set_type(static_cast< ::Hekate::Protobuf::Proto::Client::MessageType >(value));
          } else {
            mutable_unknown_fields()->AddVarint(1, value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_add_hook;
        break;
      }

      // optional .Hekate.Protobuf.Proto.Client.AddHookMessage add_hook = 2;
      case 2: {
        if (tag == 18) {
         parse_add_hook:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_add_hook()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_remove_hook;
        break;
      }

      // optional .Hekate.Protobuf.Proto.Client.RemoveHookMessage remove_hook = 3;
      case 3: {
        if (tag == 26) {
         parse_remove_hook:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_remove_hook()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(34)) goto parse_add_filter;
        break;
      }

      // optional .Hekate.Protobuf.Proto.Client.AddFilterMessage add_filter = 4;
      case 4: {
        if (tag == 34) {
         parse_add_filter:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_add_filter()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(42)) goto parse_remove_filter;
        break;
      }

      // optional .Hekate.Protobuf.Proto.Client.RemoveFilterMessage remove_filter = 5;
      case 5: {
        if (tag == 42) {
         parse_remove_filter:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_remove_filter()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(50)) goto parse_replay;
        break;
      }

      // optional .Hekate.Protobuf.Proto.Client.ReplayMessage replay = 6;
      case 6: {
        if (tag == 50) {
         parse_replay:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_replay()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(56)) goto parse_continue;
        break;
      }

      // optional bool continue = 7;
      case 7: {
        if (tag == 56) {
         parse_continue:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &continue__)));
          set_has_continue_();
        } 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.Client.ClientToHekateMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:Hekate.Protobuf.Proto.Client.ClientToHekateMessage)
  return false;
#undef DO_
}

void ClientToHekateMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:Hekate.Protobuf.Proto.Client.ClientToHekateMessage)
  // required .Hekate.Protobuf.Proto.Client.MessageType type = 1;
  if (has_type()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->type(), output);
  }

  // optional .Hekate.Protobuf.Proto.Client.AddHookMessage add_hook = 2;
  if (has_add_hook()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      2, *this->add_hook_, output);
  }

  // optional .Hekate.Protobuf.Proto.Client.RemoveHookMessage remove_hook = 3;
  if (has_remove_hook()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      3, *this->remove_hook_, output);
  }

  // optional .Hekate.Protobuf.Proto.Client.AddFilterMessage add_filter = 4;
  if (has_add_filter()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      4, *this->add_filter_, output);
  }

  // optional .Hekate.Protobuf.Proto.Client.RemoveFilterMessage remove_filter = 5;
  if (has_remove_filter()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      5, *this->remove_filter_, output);
  }

  // optional .Hekate.Protobuf.Proto.Client.ReplayMessage replay = 6;
  if (has_replay()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      6, *this->replay_, output);
  }

  // optional bool continue = 7;
  if (has_continue_()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(7, this->continue_(), output);
  }

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

::google::protobuf::uint8* ClientToHekateMessage::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:Hekate.Protobuf.Proto.Client.ClientToHekateMessage)
  // required .Hekate.Protobuf.Proto.Client.MessageType type = 1;
  if (has_type()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->type(), target);
  }

  // optional .Hekate.Protobuf.Proto.Client.AddHookMessage add_hook = 2;
  if (has_add_hook()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        2, *this->add_hook_, target);
  }

  // optional .Hekate.Protobuf.Proto.Client.RemoveHookMessage remove_hook = 3;
  if (has_remove_hook()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        3, *this->remove_hook_, target);
  }

  // optional .Hekate.Protobuf.Proto.Client.AddFilterMessage add_filter = 4;
  if (has_add_filter()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        4, *this->add_filter_, target);
  }

  // optional .Hekate.Protobuf.Proto.Client.RemoveFilterMessage remove_filter = 5;
  if (has_remove_filter()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        5, *this->remove_filter_, target);
  }

  // optional .Hekate.Protobuf.Proto.Client.ReplayMessage replay = 6;
  if (has_replay()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        6, *this->replay_, target);
  }

  // optional bool continue = 7;
  if (has_continue_()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(7, this->continue_(), 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.Client.ClientToHekateMessage)
  return target;
}

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

  // required .Hekate.Protobuf.Proto.Client.MessageType type = 1;
  if (has_type()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::EnumSize(this->type());
  }
  if (_has_bits_[1 / 32] & 126) {
    // optional .Hekate.Protobuf.Proto.Client.AddHookMessage add_hook = 2;
    if (has_add_hook()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *this->add_hook_);
    }

    // optional .Hekate.Protobuf.Proto.Client.RemoveHookMessage remove_hook = 3;
    if (has_remove_hook()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *this->remove_hook_);
    }

    // optional .Hekate.Protobuf.Proto.Client.AddFilterMessage add_filter = 4;
    if (has_add_filter()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *this->add_filter_);
    }

    // optional .Hekate.Protobuf.Proto.Client.RemoveFilterMessage remove_filter = 5;
    if (has_remove_filter()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *this->remove_filter_);
    }

    // optional .Hekate.Protobuf.Proto.Client.ReplayMessage replay = 6;
    if (has_replay()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *this->replay_);
    }

    // optional bool continue = 7;
    if (has_continue_()) {
      total_size += 1 + 1;
    }

  }
  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 ClientToHekateMessage::MergeFrom(const ::google::protobuf::Message& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  const ClientToHekateMessage* source = 
      ::google::protobuf::internal::DynamicCastToGenerated<const ClientToHekateMessage>(
          &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void ClientToHekateMessage::MergeFrom(const ClientToHekateMessage& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_type()) {
      set_type(from.type());
    }
    if (from.has_add_hook()) {
      mutable_add_hook()->::Hekate::Protobuf::Proto::Client::AddHookMessage::MergeFrom(from.add_hook());
    }
    if (from.has_remove_hook()) {
      mutable_remove_hook()->::Hekate::Protobuf::Proto::Client::RemoveHookMessage::MergeFrom(from.remove_hook());
    }
    if (from.has_add_filter()) {
      mutable_add_filter()->::Hekate::Protobuf::Proto::Client::AddFilterMessage::MergeFrom(from.add_filter());
    }
    if (from.has_remove_filter()) {
      mutable_remove_filter()->::Hekate::Protobuf::Proto::Client::RemoveFilterMessage::MergeFrom(from.remove_filter());
    }
    if (from.has_replay()) {
      mutable_replay()->::Hekate::Protobuf::Proto::Client::ReplayMessage::MergeFrom(from.replay());
    }
    if (from.has_continue_()) {
      set_continue_(from.continue_());
    }
  }
  if (from._internal_metadata_.have_unknown_fields()) {
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
}

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

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

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

  if (has_add_hook()) {
    if (!this->add_hook_->IsInitialized()) return false;
  }
  if (has_remove_hook()) {
    if (!this->remove_hook_->IsInitialized()) return false;
  }
  if (has_add_filter()) {
    if (!this->add_filter_->IsInitialized()) return false;
  }
  if (has_remove_filter()) {
    if (!this->remove_filter_->IsInitialized()) return false;
  }
  if (has_replay()) {
    if (!this->replay_->IsInitialized()) return false;
  }
  return true;
}

void ClientToHekateMessage::Swap(ClientToHekateMessage* other) {
  if (other == this) return;
  InternalSwap(other);
}
void ClientToHekateMessage::InternalSwap(ClientToHekateMessage* other) {
  std::swap(type_, other->type_);
  std::swap(add_hook_, other->add_hook_);
  std::swap(remove_hook_, other->remove_hook_);
  std::swap(add_filter_, other->add_filter_);
  std::swap(remove_filter_, other->remove_filter_);
  std::swap(replay_, other->replay_);
  std::swap(continue__, other->continue__);
  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 ClientToHekateMessage::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = ClientToHekateMessage_descriptor_;
  metadata.reflection = ClientToHekateMessage_reflection_;
  return metadata;
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// ClientToHekateMessage

// required .Hekate.Protobuf.Proto.Client.MessageType type = 1;
bool ClientToHekateMessage::has_type() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void ClientToHekateMessage::set_has_type() {
  _has_bits_[0] |= 0x00000001u;
}
void ClientToHekateMessage::clear_has_type() {
  _has_bits_[0] &= ~0x00000001u;
}
void ClientToHekateMessage::clear_type() {
  type_ = 0;
  clear_has_type();
}
 ::Hekate::Protobuf::Proto::Client::MessageType ClientToHekateMessage::type() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Client.ClientToHekateMessage.type)
  return static_cast< ::Hekate::Protobuf::Proto::Client::MessageType >(type_);
}
 void ClientToHekateMessage::set_type(::Hekate::Protobuf::Proto::Client::MessageType value) {
  assert(::Hekate::Protobuf::Proto::Client::MessageType_IsValid(value));
  set_has_type();
  type_ = value;
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Client.ClientToHekateMessage.type)
}

// optional .Hekate.Protobuf.Proto.Client.AddHookMessage add_hook = 2;
bool ClientToHekateMessage::has_add_hook() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void ClientToHekateMessage::set_has_add_hook() {
  _has_bits_[0] |= 0x00000002u;
}
void ClientToHekateMessage::clear_has_add_hook() {
  _has_bits_[0] &= ~0x00000002u;
}
void ClientToHekateMessage::clear_add_hook() {
  if (add_hook_ != NULL) add_hook_->::Hekate::Protobuf::Proto::Client::AddHookMessage::Clear();
  clear_has_add_hook();
}
 const ::Hekate::Protobuf::Proto::Client::AddHookMessage& ClientToHekateMessage::add_hook() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Client.ClientToHekateMessage.add_hook)
  return add_hook_ != NULL ? *add_hook_ : *default_instance_->add_hook_;
}
 ::Hekate::Protobuf::Proto::Client::AddHookMessage* ClientToHekateMessage::mutable_add_hook() {
  set_has_add_hook();
  if (add_hook_ == NULL) {
    add_hook_ = new ::Hekate::Protobuf::Proto::Client::AddHookMessage;
  }
  // @@protoc_insertion_point(field_mutable:Hekate.Protobuf.Proto.Client.ClientToHekateMessage.add_hook)
  return add_hook_;
}
 ::Hekate::Protobuf::Proto::Client::AddHookMessage* ClientToHekateMessage::release_add_hook() {
  clear_has_add_hook();
  ::Hekate::Protobuf::Proto::Client::AddHookMessage* temp = add_hook_;
  add_hook_ = NULL;
  return temp;
}
 void ClientToHekateMessage::set_allocated_add_hook(::Hekate::Protobuf::Proto::Client::AddHookMessage* add_hook) {
  delete add_hook_;
  add_hook_ = add_hook;
  if (add_hook) {
    set_has_add_hook();
  } else {
    clear_has_add_hook();
  }
  // @@protoc_insertion_point(field_set_allocated:Hekate.Protobuf.Proto.Client.ClientToHekateMessage.add_hook)
}

// optional .Hekate.Protobuf.Proto.Client.RemoveHookMessage remove_hook = 3;
bool ClientToHekateMessage::has_remove_hook() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
void ClientToHekateMessage::set_has_remove_hook() {
  _has_bits_[0] |= 0x00000004u;
}
void ClientToHekateMessage::clear_has_remove_hook() {
  _has_bits_[0] &= ~0x00000004u;
}
void ClientToHekateMessage::clear_remove_hook() {
  if (remove_hook_ != NULL) remove_hook_->::Hekate::Protobuf::Proto::Client::RemoveHookMessage::Clear();
  clear_has_remove_hook();
}
 const ::Hekate::Protobuf::Proto::Client::RemoveHookMessage& ClientToHekateMessage::remove_hook() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Client.ClientToHekateMessage.remove_hook)
  return remove_hook_ != NULL ? *remove_hook_ : *default_instance_->remove_hook_;
}
 ::Hekate::Protobuf::Proto::Client::RemoveHookMessage* ClientToHekateMessage::mutable_remove_hook() {
  set_has_remove_hook();
  if (remove_hook_ == NULL) {
    remove_hook_ = new ::Hekate::Protobuf::Proto::Client::RemoveHookMessage;
  }
  // @@protoc_insertion_point(field_mutable:Hekate.Protobuf.Proto.Client.ClientToHekateMessage.remove_hook)
  return remove_hook_;
}
 ::Hekate::Protobuf::Proto::Client::RemoveHookMessage* ClientToHekateMessage::release_remove_hook() {
  clear_has_remove_hook();
  ::Hekate::Protobuf::Proto::Client::RemoveHookMessage* temp = remove_hook_;
  remove_hook_ = NULL;
  return temp;
}
 void ClientToHekateMessage::set_allocated_remove_hook(::Hekate::Protobuf::Proto::Client::RemoveHookMessage* remove_hook) {
  delete remove_hook_;
  remove_hook_ = remove_hook;
  if (remove_hook) {
    set_has_remove_hook();
  } else {
    clear_has_remove_hook();
  }
  // @@protoc_insertion_point(field_set_allocated:Hekate.Protobuf.Proto.Client.ClientToHekateMessage.remove_hook)
}

// optional .Hekate.Protobuf.Proto.Client.AddFilterMessage add_filter = 4;
bool ClientToHekateMessage::has_add_filter() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
void ClientToHekateMessage::set_has_add_filter() {
  _has_bits_[0] |= 0x00000008u;
}
void ClientToHekateMessage::clear_has_add_filter() {
  _has_bits_[0] &= ~0x00000008u;
}
void ClientToHekateMessage::clear_add_filter() {
  if (add_filter_ != NULL) add_filter_->::Hekate::Protobuf::Proto::Client::AddFilterMessage::Clear();
  clear_has_add_filter();
}
 const ::Hekate::Protobuf::Proto::Client::AddFilterMessage& ClientToHekateMessage::add_filter() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Client.ClientToHekateMessage.add_filter)
  return add_filter_ != NULL ? *add_filter_ : *default_instance_->add_filter_;
}
 ::Hekate::Protobuf::Proto::Client::AddFilterMessage* ClientToHekateMessage::mutable_add_filter() {
  set_has_add_filter();
  if (add_filter_ == NULL) {
    add_filter_ = new ::Hekate::Protobuf::Proto::Client::AddFilterMessage;
  }
  // @@protoc_insertion_point(field_mutable:Hekate.Protobuf.Proto.Client.ClientToHekateMessage.add_filter)
  return add_filter_;
}
 ::Hekate::Protobuf::Proto::Client::AddFilterMessage* ClientToHekateMessage::release_add_filter() {
  clear_has_add_filter();
  ::Hekate::Protobuf::Proto::Client::AddFilterMessage* temp = add_filter_;
  add_filter_ = NULL;
  return temp;
}
 void ClientToHekateMessage::set_allocated_add_filter(::Hekate::Protobuf::Proto::Client::AddFilterMessage* add_filter) {
  delete add_filter_;
  add_filter_ = add_filter;
  if (add_filter) {
    set_has_add_filter();
  } else {
    clear_has_add_filter();
  }
  // @@protoc_insertion_point(field_set_allocated:Hekate.Protobuf.Proto.Client.ClientToHekateMessage.add_filter)
}

// optional .Hekate.Protobuf.Proto.Client.RemoveFilterMessage remove_filter = 5;
bool ClientToHekateMessage::has_remove_filter() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
void ClientToHekateMessage::set_has_remove_filter() {
  _has_bits_[0] |= 0x00000010u;
}
void ClientToHekateMessage::clear_has_remove_filter() {
  _has_bits_[0] &= ~0x00000010u;
}
void ClientToHekateMessage::clear_remove_filter() {
  if (remove_filter_ != NULL) remove_filter_->::Hekate::Protobuf::Proto::Client::RemoveFilterMessage::Clear();
  clear_has_remove_filter();
}
 const ::Hekate::Protobuf::Proto::Client::RemoveFilterMessage& ClientToHekateMessage::remove_filter() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Client.ClientToHekateMessage.remove_filter)
  return remove_filter_ != NULL ? *remove_filter_ : *default_instance_->remove_filter_;
}
 ::Hekate::Protobuf::Proto::Client::RemoveFilterMessage* ClientToHekateMessage::mutable_remove_filter() {
  set_has_remove_filter();
  if (remove_filter_ == NULL) {
    remove_filter_ = new ::Hekate::Protobuf::Proto::Client::RemoveFilterMessage;
  }
  // @@protoc_insertion_point(field_mutable:Hekate.Protobuf.Proto.Client.ClientToHekateMessage.remove_filter)
  return remove_filter_;
}
 ::Hekate::Protobuf::Proto::Client::RemoveFilterMessage* ClientToHekateMessage::release_remove_filter() {
  clear_has_remove_filter();
  ::Hekate::Protobuf::Proto::Client::RemoveFilterMessage* temp = remove_filter_;
  remove_filter_ = NULL;
  return temp;
}
 void ClientToHekateMessage::set_allocated_remove_filter(::Hekate::Protobuf::Proto::Client::RemoveFilterMessage* remove_filter) {
  delete remove_filter_;
  remove_filter_ = remove_filter;
  if (remove_filter) {
    set_has_remove_filter();
  } else {
    clear_has_remove_filter();
  }
  // @@protoc_insertion_point(field_set_allocated:Hekate.Protobuf.Proto.Client.ClientToHekateMessage.remove_filter)
}

// optional .Hekate.Protobuf.Proto.Client.ReplayMessage replay = 6;
bool ClientToHekateMessage::has_replay() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
void ClientToHekateMessage::set_has_replay() {
  _has_bits_[0] |= 0x00000020u;
}
void ClientToHekateMessage::clear_has_replay() {
  _has_bits_[0] &= ~0x00000020u;
}
void ClientToHekateMessage::clear_replay() {
  if (replay_ != NULL) replay_->::Hekate::Protobuf::Proto::Client::ReplayMessage::Clear();
  clear_has_replay();
}
 const ::Hekate::Protobuf::Proto::Client::ReplayMessage& ClientToHekateMessage::replay() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Client.ClientToHekateMessage.replay)
  return replay_ != NULL ? *replay_ : *default_instance_->replay_;
}
 ::Hekate::Protobuf::Proto::Client::ReplayMessage* ClientToHekateMessage::mutable_replay() {
  set_has_replay();
  if (replay_ == NULL) {
    replay_ = new ::Hekate::Protobuf::Proto::Client::ReplayMessage;
  }
  // @@protoc_insertion_point(field_mutable:Hekate.Protobuf.Proto.Client.ClientToHekateMessage.replay)
  return replay_;
}
 ::Hekate::Protobuf::Proto::Client::ReplayMessage* ClientToHekateMessage::release_replay() {
  clear_has_replay();
  ::Hekate::Protobuf::Proto::Client::ReplayMessage* temp = replay_;
  replay_ = NULL;
  return temp;
}
 void ClientToHekateMessage::set_allocated_replay(::Hekate::Protobuf::Proto::Client::ReplayMessage* replay) {
  delete replay_;
  replay_ = replay;
  if (replay) {
    set_has_replay();
  } else {
    clear_has_replay();
  }
  // @@protoc_insertion_point(field_set_allocated:Hekate.Protobuf.Proto.Client.ClientToHekateMessage.replay)
}

// optional bool continue = 7;
bool ClientToHekateMessage::has_continue_() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
void ClientToHekateMessage::set_has_continue_() {
  _has_bits_[0] |= 0x00000040u;
}
void ClientToHekateMessage::clear_has_continue_() {
  _has_bits_[0] &= ~0x00000040u;
}
void ClientToHekateMessage::clear_continue_() {
  continue__ = false;
  clear_has_continue_();
}
 bool ClientToHekateMessage::continue_() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Client.ClientToHekateMessage.continue)
  return continue__;
}
 void ClientToHekateMessage::set_continue_(bool value) {
  set_has_continue_();
  continue__ = value;
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Client.ClientToHekateMessage.continue)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#ifndef _MSC_VER
const int HekateClientMessage::kClientMessageFieldNumber;
const int HekateClientMessage::kDebugResponseIdFieldNumber;
#endif  // !_MSC_VER

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

void HekateClientMessage::InitAsDefaultInstance() {
  clientmessage_ = const_cast< ::Hekate::Protobuf::Proto::Client::ClientToHekateMessage*>(&::Hekate::Protobuf::Proto::Client::ClientToHekateMessage::default_instance());
}

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

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

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

void HekateClientMessage::SharedDtor() {
  if (this != default_instance_) {
    delete clientmessage_;
  }
}

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

const HekateClientMessage& HekateClientMessage::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_HekateClientProto_2eproto();
  return *default_instance_;
}

HekateClientMessage* HekateClientMessage::default_instance_ = NULL;

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

void HekateClientMessage::Clear() {
  if (_has_bits_[0 / 32] & 3u) {
    if (has_clientmessage()) {
      if (clientmessage_ != NULL) clientmessage_->::Hekate::Protobuf::Proto::Client::ClientToHekateMessage::Clear();
    }
    debug_response_id_ = 0;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  if (_internal_metadata_.have_unknown_fields()) {
    mutable_unknown_fields()->Clear();
  }
}

bool HekateClientMessage::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.Client.HekateClientMessage)
  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.Client.ClientToHekateMessage clientMessage = 1;
      case 1: {
        if (tag == 10) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_clientmessage()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_debug_response_id;
        break;
      }

      // optional int32 debug_response_id = 2;
      case 2: {
        if (tag == 16) {
         parse_debug_response_id:
          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.Client.HekateClientMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:Hekate.Protobuf.Proto.Client.HekateClientMessage)
  return false;
#undef DO_
}

void HekateClientMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:Hekate.Protobuf.Proto.Client.HekateClientMessage)
  // required .Hekate.Protobuf.Proto.Client.ClientToHekateMessage clientMessage = 1;
  if (has_clientmessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, *this->clientmessage_, output);
  }

  // optional int32 debug_response_id = 2;
  if (has_debug_response_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, 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.Client.HekateClientMessage)
}

::google::protobuf::uint8* HekateClientMessage::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:Hekate.Protobuf.Proto.Client.HekateClientMessage)
  // required .Hekate.Protobuf.Proto.Client.ClientToHekateMessage clientMessage = 1;
  if (has_clientmessage()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, *this->clientmessage_, target);
  }

  // optional int32 debug_response_id = 2;
  if (has_debug_response_id()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, 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.Client.HekateClientMessage)
  return target;
}

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

  // required .Hekate.Protobuf.Proto.Client.ClientToHekateMessage clientMessage = 1;
  if (has_clientmessage()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        *this->clientmessage_);
  }
  // optional int32 debug_response_id = 2;
  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 HekateClientMessage::MergeFrom(const ::google::protobuf::Message& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  const HekateClientMessage* source = 
      ::google::protobuf::internal::DynamicCastToGenerated<const HekateClientMessage>(
          &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void HekateClientMessage::MergeFrom(const HekateClientMessage& from) {
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_clientmessage()) {
      mutable_clientmessage()->::Hekate::Protobuf::Proto::Client::ClientToHekateMessage::MergeFrom(from.clientmessage());
    }
    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 HekateClientMessage::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

  if (has_clientmessage()) {
    if (!this->clientmessage_->IsInitialized()) return false;
  }
  return true;
}

void HekateClientMessage::Swap(HekateClientMessage* other) {
  if (other == this) return;
  InternalSwap(other);
}
void HekateClientMessage::InternalSwap(HekateClientMessage* other) {
  std::swap(clientmessage_, other->clientmessage_);
  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 HekateClientMessage::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = HekateClientMessage_descriptor_;
  metadata.reflection = HekateClientMessage_reflection_;
  return metadata;
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// HekateClientMessage

// required .Hekate.Protobuf.Proto.Client.ClientToHekateMessage clientMessage = 1;
bool HekateClientMessage::has_clientmessage() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void HekateClientMessage::set_has_clientmessage() {
  _has_bits_[0] |= 0x00000001u;
}
void HekateClientMessage::clear_has_clientmessage() {
  _has_bits_[0] &= ~0x00000001u;
}
void HekateClientMessage::clear_clientmessage() {
  if (clientmessage_ != NULL) clientmessage_->::Hekate::Protobuf::Proto::Client::ClientToHekateMessage::Clear();
  clear_has_clientmessage();
}
 const ::Hekate::Protobuf::Proto::Client::ClientToHekateMessage& HekateClientMessage::clientmessage() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Client.HekateClientMessage.clientMessage)
  return clientmessage_ != NULL ? *clientmessage_ : *default_instance_->clientmessage_;
}
 ::Hekate::Protobuf::Proto::Client::ClientToHekateMessage* HekateClientMessage::mutable_clientmessage() {
  set_has_clientmessage();
  if (clientmessage_ == NULL) {
    clientmessage_ = new ::Hekate::Protobuf::Proto::Client::ClientToHekateMessage;
  }
  // @@protoc_insertion_point(field_mutable:Hekate.Protobuf.Proto.Client.HekateClientMessage.clientMessage)
  return clientmessage_;
}
 ::Hekate::Protobuf::Proto::Client::ClientToHekateMessage* HekateClientMessage::release_clientmessage() {
  clear_has_clientmessage();
  ::Hekate::Protobuf::Proto::Client::ClientToHekateMessage* temp = clientmessage_;
  clientmessage_ = NULL;
  return temp;
}
 void HekateClientMessage::set_allocated_clientmessage(::Hekate::Protobuf::Proto::Client::ClientToHekateMessage* clientmessage) {
  delete clientmessage_;
  clientmessage_ = clientmessage;
  if (clientmessage) {
    set_has_clientmessage();
  } else {
    clear_has_clientmessage();
  }
  // @@protoc_insertion_point(field_set_allocated:Hekate.Protobuf.Proto.Client.HekateClientMessage.clientMessage)
}

// optional int32 debug_response_id = 2;
bool HekateClientMessage::has_debug_response_id() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void HekateClientMessage::set_has_debug_response_id() {
  _has_bits_[0] |= 0x00000002u;
}
void HekateClientMessage::clear_has_debug_response_id() {
  _has_bits_[0] &= ~0x00000002u;
}
void HekateClientMessage::clear_debug_response_id() {
  debug_response_id_ = 0;
  clear_has_debug_response_id();
}
 ::google::protobuf::int32 HekateClientMessage::debug_response_id() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Client.HekateClientMessage.debug_response_id)
  return debug_response_id_;
}
 void HekateClientMessage::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.Client.HekateClientMessage.debug_response_id)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

// @@protoc_insertion_point(namespace_scope)

}  // namespace Client
}  // namespace Proto
}  // namespace Protobuf
}  // namespace Hekate

// @@protoc_insertion_point(global_scope)
