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

#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
#include "chatcleaner.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>
// @@protoc_insertion_point(includes)

void protobuf_ShutdownFile_chatcleaner_2eproto() {
  delete CleanerInitMessage::default_instance_;
  delete CleanerInitAckMessage::default_instance_;
  delete CleanerChatRequestMessage::default_instance_;
  delete CleanerChatReplyMessage::default_instance_;
  delete ChatCleanerMessage::default_instance_;
}

#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
void protobuf_AddDesc_chatcleaner_2eproto_impl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#else
void protobuf_AddDesc_chatcleaner_2eproto() {
  static bool already_here = false;
  if (already_here) return;
  already_here = true;
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#endif
  CleanerInitMessage::default_instance_ = new CleanerInitMessage();
  CleanerInitAckMessage::default_instance_ = new CleanerInitAckMessage();
  CleanerChatRequestMessage::default_instance_ = new CleanerChatRequestMessage();
  CleanerChatReplyMessage::default_instance_ = new CleanerChatReplyMessage();
  ChatCleanerMessage::default_instance_ = new ChatCleanerMessage();
  CleanerInitMessage::default_instance_->InitAsDefaultInstance();
  CleanerInitAckMessage::default_instance_->InitAsDefaultInstance();
  CleanerChatRequestMessage::default_instance_->InitAsDefaultInstance();
  CleanerChatReplyMessage::default_instance_->InitAsDefaultInstance();
  ChatCleanerMessage::default_instance_->InitAsDefaultInstance();
  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_chatcleaner_2eproto);
}

#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AddDesc_chatcleaner_2eproto_once_);
void protobuf_AddDesc_chatcleaner_2eproto() {
  ::google::protobuf::::google::protobuf::GoogleOnceInit(&protobuf_AddDesc_chatcleaner_2eproto_once_,
                 &protobuf_AddDesc_chatcleaner_2eproto_impl);
}
#else
// Force AddDescriptors() to be called at static initialization time.
struct StaticDescriptorInitializer_chatcleaner_2eproto {
  StaticDescriptorInitializer_chatcleaner_2eproto() {
    protobuf_AddDesc_chatcleaner_2eproto();
  }
} static_descriptor_initializer_chatcleaner_2eproto_;
#endif
bool CleanerChatType_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
      return true;
    default:
      return false;
  }
}


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

#ifndef _MSC_VER
const int CleanerInitMessage::kRequestedVersionFieldNumber;
const int CleanerInitMessage::kClientSecretFieldNumber;
#endif  // !_MSC_VER

CleanerInitMessage::CleanerInitMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
}

void CleanerInitMessage::InitAsDefaultInstance() {
}

CleanerInitMessage::CleanerInitMessage(const CleanerInitMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
}

void CleanerInitMessage::SharedCtor() {
  _cached_size_ = 0;
  requestedversion_ = 0u;
  clientsecret_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CleanerInitMessage::~CleanerInitMessage() {
  SharedDtor();
}

void CleanerInitMessage::SharedDtor() {
  if (clientsecret_ != &::google::protobuf::internal::kEmptyString) {
    delete clientsecret_;
  }
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void CleanerInitMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const CleanerInitMessage& CleanerInitMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_chatcleaner_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_chatcleaner_2eproto();
#endif
  return *default_instance_;
}

CleanerInitMessage* CleanerInitMessage::default_instance_ = NULL;

CleanerInitMessage* CleanerInitMessage::New() const {
  return new CleanerInitMessage;
}

void CleanerInitMessage::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    requestedversion_ = 0u;
    if (has_clientsecret()) {
      if (clientsecret_ != &::google::protobuf::internal::kEmptyString) {
        clientsecret_->clear();
      }
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

bool CleanerInitMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 requestedVersion = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &requestedversion_)));
          set_has_requestedversion();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_clientSecret;
        break;
      }

      // required string clientSecret = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_clientSecret:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_clientsecret()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void CleanerInitMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required uint32 requestedVersion = 1;
  if (has_requestedversion()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->requestedversion(), output);
  }

  // required string clientSecret = 2;
  if (has_clientsecret()) {
    ::google::protobuf::internal::WireFormatLite::WriteString(
      2, this->clientsecret(), output);
  }

}

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 requestedVersion = 1;
    if (has_requestedversion()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->requestedversion());
    }

    // required string clientSecret = 2;
    if (has_clientsecret()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->clientsecret());
    }

  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void CleanerInitMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const CleanerInitMessage*>(&from));
}

void CleanerInitMessage::MergeFrom(const CleanerInitMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_requestedversion()) {
      set_requestedversion(from.requestedversion());
    }
    if (from.has_clientsecret()) {
      set_clientsecret(from.clientsecret());
    }
  }
}

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

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

  return true;
}

void CleanerInitMessage::Swap(CleanerInitMessage* other) {
  if (other != this) {
    std::swap(requestedversion_, other->requestedversion_);
    std::swap(clientsecret_, other->clientsecret_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string CleanerInitMessage::GetTypeName() const {
  return "CleanerInitMessage";
}


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

#ifndef _MSC_VER
const int CleanerInitAckMessage::kServerVersionFieldNumber;
const int CleanerInitAckMessage::kServerSecretFieldNumber;
#endif  // !_MSC_VER

CleanerInitAckMessage::CleanerInitAckMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
}

void CleanerInitAckMessage::InitAsDefaultInstance() {
}

CleanerInitAckMessage::CleanerInitAckMessage(const CleanerInitAckMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
}

void CleanerInitAckMessage::SharedCtor() {
  _cached_size_ = 0;
  serverversion_ = 0u;
  serversecret_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CleanerInitAckMessage::~CleanerInitAckMessage() {
  SharedDtor();
}

void CleanerInitAckMessage::SharedDtor() {
  if (serversecret_ != &::google::protobuf::internal::kEmptyString) {
    delete serversecret_;
  }
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void CleanerInitAckMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const CleanerInitAckMessage& CleanerInitAckMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_chatcleaner_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_chatcleaner_2eproto();
#endif
  return *default_instance_;
}

CleanerInitAckMessage* CleanerInitAckMessage::default_instance_ = NULL;

CleanerInitAckMessage* CleanerInitAckMessage::New() const {
  return new CleanerInitAckMessage;
}

void CleanerInitAckMessage::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    serverversion_ = 0u;
    if (has_serversecret()) {
      if (serversecret_ != &::google::protobuf::internal::kEmptyString) {
        serversecret_->clear();
      }
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

bool CleanerInitAckMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 serverVersion = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &serverversion_)));
          set_has_serverversion();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_serverSecret;
        break;
      }

      // required string serverSecret = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_serverSecret:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_serversecret()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void CleanerInitAckMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required uint32 serverVersion = 1;
  if (has_serverversion()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->serverversion(), output);
  }

  // required string serverSecret = 2;
  if (has_serversecret()) {
    ::google::protobuf::internal::WireFormatLite::WriteString(
      2, this->serversecret(), output);
  }

}

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 serverVersion = 1;
    if (has_serverversion()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->serverversion());
    }

    // required string serverSecret = 2;
    if (has_serversecret()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->serversecret());
    }

  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void CleanerInitAckMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const CleanerInitAckMessage*>(&from));
}

void CleanerInitAckMessage::MergeFrom(const CleanerInitAckMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_serverversion()) {
      set_serverversion(from.serverversion());
    }
    if (from.has_serversecret()) {
      set_serversecret(from.serversecret());
    }
  }
}

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

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

  return true;
}

void CleanerInitAckMessage::Swap(CleanerInitAckMessage* other) {
  if (other != this) {
    std::swap(serverversion_, other->serverversion_);
    std::swap(serversecret_, other->serversecret_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string CleanerInitAckMessage::GetTypeName() const {
  return "CleanerInitAckMessage";
}


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

#ifndef _MSC_VER
const int CleanerChatRequestMessage::kRequestIdFieldNumber;
const int CleanerChatRequestMessage::kCleanerChatTypeFieldNumber;
const int CleanerChatRequestMessage::kGameIdFieldNumber;
const int CleanerChatRequestMessage::kPlayerIdFieldNumber;
const int CleanerChatRequestMessage::kPlayerNameFieldNumber;
const int CleanerChatRequestMessage::kChatMessageFieldNumber;
#endif  // !_MSC_VER

CleanerChatRequestMessage::CleanerChatRequestMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
}

void CleanerChatRequestMessage::InitAsDefaultInstance() {
}

CleanerChatRequestMessage::CleanerChatRequestMessage(const CleanerChatRequestMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
}

void CleanerChatRequestMessage::SharedCtor() {
  _cached_size_ = 0;
  requestid_ = 0u;
  cleanerchattype_ = 0;
  gameid_ = 0u;
  playerid_ = 0u;
  playername_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  chatmessage_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CleanerChatRequestMessage::~CleanerChatRequestMessage() {
  SharedDtor();
}

void CleanerChatRequestMessage::SharedDtor() {
  if (playername_ != &::google::protobuf::internal::kEmptyString) {
    delete playername_;
  }
  if (chatmessage_ != &::google::protobuf::internal::kEmptyString) {
    delete chatmessage_;
  }
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void CleanerChatRequestMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const CleanerChatRequestMessage& CleanerChatRequestMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_chatcleaner_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_chatcleaner_2eproto();
#endif
  return *default_instance_;
}

CleanerChatRequestMessage* CleanerChatRequestMessage::default_instance_ = NULL;

CleanerChatRequestMessage* CleanerChatRequestMessage::New() const {
  return new CleanerChatRequestMessage;
}

void CleanerChatRequestMessage::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    requestid_ = 0u;
    cleanerchattype_ = 0;
    gameid_ = 0u;
    playerid_ = 0u;
    if (has_playername()) {
      if (playername_ != &::google::protobuf::internal::kEmptyString) {
        playername_->clear();
      }
    }
    if (has_chatmessage()) {
      if (chatmessage_ != &::google::protobuf::internal::kEmptyString) {
        chatmessage_->clear();
      }
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

bool CleanerChatRequestMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 requestId = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &requestid_)));
          set_has_requestid();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(16)) goto parse_cleanerChatType;
        break;
      }

      // required .CleanerChatType cleanerChatType = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_cleanerChatType:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::CleanerChatType_IsValid(value)) {
            set_cleanerchattype(static_cast< ::CleanerChatType >(value));
          }
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(24)) goto parse_gameId;
        break;
      }

      // optional uint32 gameId = 3 [default = 0];
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_gameId:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &gameid_)));
          set_has_gameid();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(32)) goto parse_playerId;
        break;
      }

      // required uint32 playerId = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_playerId:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &playerid_)));
          set_has_playerid();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(42)) goto parse_playerName;
        break;
      }

      // required string playerName = 5;
      case 5: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_playerName:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_playername()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(50)) goto parse_chatMessage;
        break;
      }

      // required string chatMessage = 6;
      case 6: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_chatMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_chatmessage()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void CleanerChatRequestMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required uint32 requestId = 1;
  if (has_requestid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->requestid(), output);
  }

  // required .CleanerChatType cleanerChatType = 2;
  if (has_cleanerchattype()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      2, this->cleanerchattype(), output);
  }

  // optional uint32 gameId = 3 [default = 0];
  if (has_gameid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->gameid(), output);
  }

  // required uint32 playerId = 4;
  if (has_playerid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->playerid(), output);
  }

  // required string playerName = 5;
  if (has_playername()) {
    ::google::protobuf::internal::WireFormatLite::WriteString(
      5, this->playername(), output);
  }

  // required string chatMessage = 6;
  if (has_chatmessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteString(
      6, this->chatmessage(), output);
  }

}

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 requestId = 1;
    if (has_requestid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->requestid());
    }

    // required .CleanerChatType cleanerChatType = 2;
    if (has_cleanerchattype()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->cleanerchattype());
    }

    // optional uint32 gameId = 3 [default = 0];
    if (has_gameid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->gameid());
    }

    // required uint32 playerId = 4;
    if (has_playerid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->playerid());
    }

    // required string playerName = 5;
    if (has_playername()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->playername());
    }

    // required string chatMessage = 6;
    if (has_chatmessage()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->chatmessage());
    }

  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void CleanerChatRequestMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const CleanerChatRequestMessage*>(&from));
}

void CleanerChatRequestMessage::MergeFrom(const CleanerChatRequestMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_requestid()) {
      set_requestid(from.requestid());
    }
    if (from.has_cleanerchattype()) {
      set_cleanerchattype(from.cleanerchattype());
    }
    if (from.has_gameid()) {
      set_gameid(from.gameid());
    }
    if (from.has_playerid()) {
      set_playerid(from.playerid());
    }
    if (from.has_playername()) {
      set_playername(from.playername());
    }
    if (from.has_chatmessage()) {
      set_chatmessage(from.chatmessage());
    }
  }
}

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

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

  return true;
}

void CleanerChatRequestMessage::Swap(CleanerChatRequestMessage* other) {
  if (other != this) {
    std::swap(requestid_, other->requestid_);
    std::swap(cleanerchattype_, other->cleanerchattype_);
    std::swap(gameid_, other->gameid_);
    std::swap(playerid_, other->playerid_);
    std::swap(playername_, other->playername_);
    std::swap(chatmessage_, other->chatmessage_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string CleanerChatRequestMessage::GetTypeName() const {
  return "CleanerChatRequestMessage";
}


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

bool CleanerChatReplyMessage_CleanerActionType_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
      return true;
    default:
      return false;
  }
}

#ifndef _MSC_VER
const CleanerChatReplyMessage_CleanerActionType CleanerChatReplyMessage::cleanerActionNone;
const CleanerChatReplyMessage_CleanerActionType CleanerChatReplyMessage::cleanerActionWarning;
const CleanerChatReplyMessage_CleanerActionType CleanerChatReplyMessage::cleanerActionKick;
const CleanerChatReplyMessage_CleanerActionType CleanerChatReplyMessage::cleanerActionBan;
const CleanerChatReplyMessage_CleanerActionType CleanerChatReplyMessage::cleanerActionMute;
const CleanerChatReplyMessage_CleanerActionType CleanerChatReplyMessage::CleanerActionType_MIN;
const CleanerChatReplyMessage_CleanerActionType CleanerChatReplyMessage::CleanerActionType_MAX;
const int CleanerChatReplyMessage::CleanerActionType_ARRAYSIZE;
#endif  // _MSC_VER
#ifndef _MSC_VER
const int CleanerChatReplyMessage::kRequestIdFieldNumber;
const int CleanerChatReplyMessage::kCleanerChatTypeFieldNumber;
const int CleanerChatReplyMessage::kGameIdFieldNumber;
const int CleanerChatReplyMessage::kPlayerIdFieldNumber;
const int CleanerChatReplyMessage::kCleanerActionTypeFieldNumber;
const int CleanerChatReplyMessage::kCleanerTextFieldNumber;
#endif  // !_MSC_VER

CleanerChatReplyMessage::CleanerChatReplyMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
}

void CleanerChatReplyMessage::InitAsDefaultInstance() {
}

CleanerChatReplyMessage::CleanerChatReplyMessage(const CleanerChatReplyMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
}

void CleanerChatReplyMessage::SharedCtor() {
  _cached_size_ = 0;
  requestid_ = 0u;
  cleanerchattype_ = 0;
  gameid_ = 0u;
  playerid_ = 0u;
  cleaneractiontype_ = 0;
  cleanertext_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CleanerChatReplyMessage::~CleanerChatReplyMessage() {
  SharedDtor();
}

void CleanerChatReplyMessage::SharedDtor() {
  if (cleanertext_ != &::google::protobuf::internal::kEmptyString) {
    delete cleanertext_;
  }
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void CleanerChatReplyMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const CleanerChatReplyMessage& CleanerChatReplyMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_chatcleaner_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_chatcleaner_2eproto();
#endif
  return *default_instance_;
}

CleanerChatReplyMessage* CleanerChatReplyMessage::default_instance_ = NULL;

CleanerChatReplyMessage* CleanerChatReplyMessage::New() const {
  return new CleanerChatReplyMessage;
}

void CleanerChatReplyMessage::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    requestid_ = 0u;
    cleanerchattype_ = 0;
    gameid_ = 0u;
    playerid_ = 0u;
    cleaneractiontype_ = 0;
    if (has_cleanertext()) {
      if (cleanertext_ != &::google::protobuf::internal::kEmptyString) {
        cleanertext_->clear();
      }
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

bool CleanerChatReplyMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 requestId = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &requestid_)));
          set_has_requestid();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(16)) goto parse_cleanerChatType;
        break;
      }

      // required .CleanerChatType cleanerChatType = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_cleanerChatType:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::CleanerChatType_IsValid(value)) {
            set_cleanerchattype(static_cast< ::CleanerChatType >(value));
          }
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(24)) goto parse_gameId;
        break;
      }

      // optional uint32 gameId = 3 [default = 0];
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_gameId:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &gameid_)));
          set_has_gameid();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(32)) goto parse_playerId;
        break;
      }

      // required uint32 playerId = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_playerId:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &playerid_)));
          set_has_playerid();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(40)) goto parse_cleanerActionType;
        break;
      }

      // required .CleanerChatReplyMessage.CleanerActionType cleanerActionType = 5;
      case 5: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_cleanerActionType:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::CleanerChatReplyMessage_CleanerActionType_IsValid(value)) {
            set_cleaneractiontype(static_cast< ::CleanerChatReplyMessage_CleanerActionType >(value));
          }
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(50)) goto parse_cleanerText;
        break;
      }

      // optional string cleanerText = 6 [default = ""];
      case 6: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_cleanerText:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_cleanertext()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void CleanerChatReplyMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required uint32 requestId = 1;
  if (has_requestid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->requestid(), output);
  }

  // required .CleanerChatType cleanerChatType = 2;
  if (has_cleanerchattype()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      2, this->cleanerchattype(), output);
  }

  // optional uint32 gameId = 3 [default = 0];
  if (has_gameid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->gameid(), output);
  }

  // required uint32 playerId = 4;
  if (has_playerid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->playerid(), output);
  }

  // required .CleanerChatReplyMessage.CleanerActionType cleanerActionType = 5;
  if (has_cleaneractiontype()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      5, this->cleaneractiontype(), output);
  }

  // optional string cleanerText = 6 [default = ""];
  if (has_cleanertext()) {
    ::google::protobuf::internal::WireFormatLite::WriteString(
      6, this->cleanertext(), output);
  }

}

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 requestId = 1;
    if (has_requestid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->requestid());
    }

    // required .CleanerChatType cleanerChatType = 2;
    if (has_cleanerchattype()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->cleanerchattype());
    }

    // optional uint32 gameId = 3 [default = 0];
    if (has_gameid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->gameid());
    }

    // required uint32 playerId = 4;
    if (has_playerid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->playerid());
    }

    // required .CleanerChatReplyMessage.CleanerActionType cleanerActionType = 5;
    if (has_cleaneractiontype()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->cleaneractiontype());
    }

    // optional string cleanerText = 6 [default = ""];
    if (has_cleanertext()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->cleanertext());
    }

  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void CleanerChatReplyMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const CleanerChatReplyMessage*>(&from));
}

void CleanerChatReplyMessage::MergeFrom(const CleanerChatReplyMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_requestid()) {
      set_requestid(from.requestid());
    }
    if (from.has_cleanerchattype()) {
      set_cleanerchattype(from.cleanerchattype());
    }
    if (from.has_gameid()) {
      set_gameid(from.gameid());
    }
    if (from.has_playerid()) {
      set_playerid(from.playerid());
    }
    if (from.has_cleaneractiontype()) {
      set_cleaneractiontype(from.cleaneractiontype());
    }
    if (from.has_cleanertext()) {
      set_cleanertext(from.cleanertext());
    }
  }
}

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

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

  return true;
}

void CleanerChatReplyMessage::Swap(CleanerChatReplyMessage* other) {
  if (other != this) {
    std::swap(requestid_, other->requestid_);
    std::swap(cleanerchattype_, other->cleanerchattype_);
    std::swap(gameid_, other->gameid_);
    std::swap(playerid_, other->playerid_);
    std::swap(cleaneractiontype_, other->cleaneractiontype_);
    std::swap(cleanertext_, other->cleanertext_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string CleanerChatReplyMessage::GetTypeName() const {
  return "CleanerChatReplyMessage";
}


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

bool ChatCleanerMessage_ChatCleanerMessageType_IsValid(int value) {
  switch(value) {
    case 1:
    case 2:
    case 3:
    case 4:
      return true;
    default:
      return false;
  }
}

#ifndef _MSC_VER
const ChatCleanerMessage_ChatCleanerMessageType ChatCleanerMessage::Type_CleanerInitMessage;
const ChatCleanerMessage_ChatCleanerMessageType ChatCleanerMessage::Type_CleanerInitAckMessage;
const ChatCleanerMessage_ChatCleanerMessageType ChatCleanerMessage::Type_CleanerChatRequestMessage;
const ChatCleanerMessage_ChatCleanerMessageType ChatCleanerMessage::Type_CleanerChatReplyMessage;
const ChatCleanerMessage_ChatCleanerMessageType ChatCleanerMessage::ChatCleanerMessageType_MIN;
const ChatCleanerMessage_ChatCleanerMessageType ChatCleanerMessage::ChatCleanerMessageType_MAX;
const int ChatCleanerMessage::ChatCleanerMessageType_ARRAYSIZE;
#endif  // _MSC_VER
#ifndef _MSC_VER
const int ChatCleanerMessage::kMessageTypeFieldNumber;
const int ChatCleanerMessage::kCleanerInitMessageFieldNumber;
const int ChatCleanerMessage::kCleanerInitAckMessageFieldNumber;
const int ChatCleanerMessage::kCleanerChatRequestMessageFieldNumber;
const int ChatCleanerMessage::kCleanerChatReplyMessageFieldNumber;
#endif  // !_MSC_VER

ChatCleanerMessage::ChatCleanerMessage()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
}

void ChatCleanerMessage::InitAsDefaultInstance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  cleanerinitmessage_ = const_cast< ::CleanerInitMessage*>(
      ::CleanerInitMessage::internal_default_instance());
#else
  cleanerinitmessage_ = const_cast< ::CleanerInitMessage*>(&::CleanerInitMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  cleanerinitackmessage_ = const_cast< ::CleanerInitAckMessage*>(
      ::CleanerInitAckMessage::internal_default_instance());
#else
  cleanerinitackmessage_ = const_cast< ::CleanerInitAckMessage*>(&::CleanerInitAckMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  cleanerchatrequestmessage_ = const_cast< ::CleanerChatRequestMessage*>(
      ::CleanerChatRequestMessage::internal_default_instance());
#else
  cleanerchatrequestmessage_ = const_cast< ::CleanerChatRequestMessage*>(&::CleanerChatRequestMessage::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  cleanerchatreplymessage_ = const_cast< ::CleanerChatReplyMessage*>(
      ::CleanerChatReplyMessage::internal_default_instance());
#else
  cleanerchatreplymessage_ = const_cast< ::CleanerChatReplyMessage*>(&::CleanerChatReplyMessage::default_instance());
#endif
}

ChatCleanerMessage::ChatCleanerMessage(const ChatCleanerMessage& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
}

void ChatCleanerMessage::SharedCtor() {
  _cached_size_ = 0;
  messagetype_ = 1;
  cleanerinitmessage_ = NULL;
  cleanerinitackmessage_ = NULL;
  cleanerchatrequestmessage_ = NULL;
  cleanerchatreplymessage_ = NULL;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

ChatCleanerMessage::~ChatCleanerMessage() {
  SharedDtor();
}

void ChatCleanerMessage::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
    delete cleanerinitmessage_;
    delete cleanerinitackmessage_;
    delete cleanerchatrequestmessage_;
    delete cleanerchatreplymessage_;
  }
}

void ChatCleanerMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ChatCleanerMessage& ChatCleanerMessage::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_chatcleaner_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_chatcleaner_2eproto();
#endif
  return *default_instance_;
}

ChatCleanerMessage* ChatCleanerMessage::default_instance_ = NULL;

ChatCleanerMessage* ChatCleanerMessage::New() const {
  return new ChatCleanerMessage;
}

void ChatCleanerMessage::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    messagetype_ = 1;
    if (has_cleanerinitmessage()) {
      if (cleanerinitmessage_ != NULL) cleanerinitmessage_->::CleanerInitMessage::Clear();
    }
    if (has_cleanerinitackmessage()) {
      if (cleanerinitackmessage_ != NULL) cleanerinitackmessage_->::CleanerInitAckMessage::Clear();
    }
    if (has_cleanerchatrequestmessage()) {
      if (cleanerchatrequestmessage_ != NULL) cleanerchatrequestmessage_->::CleanerChatRequestMessage::Clear();
    }
    if (has_cleanerchatreplymessage()) {
      if (cleanerchatreplymessage_ != NULL) cleanerchatreplymessage_->::CleanerChatReplyMessage::Clear();
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

bool ChatCleanerMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required .ChatCleanerMessage.ChatCleanerMessageType messageType = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::ChatCleanerMessage_ChatCleanerMessageType_IsValid(value)) {
            set_messagetype(static_cast< ::ChatCleanerMessage_ChatCleanerMessageType >(value));
          }
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_cleanerInitMessage;
        break;
      }

      // optional .CleanerInitMessage cleanerInitMessage = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_cleanerInitMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_cleanerinitmessage()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(26)) goto parse_cleanerInitAckMessage;
        break;
      }

      // optional .CleanerInitAckMessage cleanerInitAckMessage = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_cleanerInitAckMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_cleanerinitackmessage()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(34)) goto parse_cleanerChatRequestMessage;
        break;
      }

      // optional .CleanerChatRequestMessage cleanerChatRequestMessage = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_cleanerChatRequestMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_cleanerchatrequestmessage()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(42)) goto parse_cleanerChatReplyMessage;
        break;
      }

      // optional .CleanerChatReplyMessage cleanerChatReplyMessage = 5;
      case 5: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_cleanerChatReplyMessage:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_cleanerchatreplymessage()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void ChatCleanerMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required .ChatCleanerMessage.ChatCleanerMessageType messageType = 1;
  if (has_messagetype()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->messagetype(), output);
  }

  // optional .CleanerInitMessage cleanerInitMessage = 2;
  if (has_cleanerinitmessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      2, this->cleanerinitmessage(), output);
  }

  // optional .CleanerInitAckMessage cleanerInitAckMessage = 3;
  if (has_cleanerinitackmessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      3, this->cleanerinitackmessage(), output);
  }

  // optional .CleanerChatRequestMessage cleanerChatRequestMessage = 4;
  if (has_cleanerchatrequestmessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      4, this->cleanerchatrequestmessage(), output);
  }

  // optional .CleanerChatReplyMessage cleanerChatReplyMessage = 5;
  if (has_cleanerchatreplymessage()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      5, this->cleanerchatreplymessage(), output);
  }

}

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required .ChatCleanerMessage.ChatCleanerMessageType messageType = 1;
    if (has_messagetype()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->messagetype());
    }

    // optional .CleanerInitMessage cleanerInitMessage = 2;
    if (has_cleanerinitmessage()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->cleanerinitmessage());
    }

    // optional .CleanerInitAckMessage cleanerInitAckMessage = 3;
    if (has_cleanerinitackmessage()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->cleanerinitackmessage());
    }

    // optional .CleanerChatRequestMessage cleanerChatRequestMessage = 4;
    if (has_cleanerchatrequestmessage()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->cleanerchatrequestmessage());
    }

    // optional .CleanerChatReplyMessage cleanerChatReplyMessage = 5;
    if (has_cleanerchatreplymessage()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->cleanerchatreplymessage());
    }

  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void ChatCleanerMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const ChatCleanerMessage*>(&from));
}

void ChatCleanerMessage::MergeFrom(const ChatCleanerMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_messagetype()) {
      set_messagetype(from.messagetype());
    }
    if (from.has_cleanerinitmessage()) {
      mutable_cleanerinitmessage()->::CleanerInitMessage::MergeFrom(from.cleanerinitmessage());
    }
    if (from.has_cleanerinitackmessage()) {
      mutable_cleanerinitackmessage()->::CleanerInitAckMessage::MergeFrom(from.cleanerinitackmessage());
    }
    if (from.has_cleanerchatrequestmessage()) {
      mutable_cleanerchatrequestmessage()->::CleanerChatRequestMessage::MergeFrom(from.cleanerchatrequestmessage());
    }
    if (from.has_cleanerchatreplymessage()) {
      mutable_cleanerchatreplymessage()->::CleanerChatReplyMessage::MergeFrom(from.cleanerchatreplymessage());
    }
  }
}

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

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

  if (has_cleanerinitmessage()) {
    if (!this->cleanerinitmessage().IsInitialized()) return false;
  }
  if (has_cleanerinitackmessage()) {
    if (!this->cleanerinitackmessage().IsInitialized()) return false;
  }
  if (has_cleanerchatrequestmessage()) {
    if (!this->cleanerchatrequestmessage().IsInitialized()) return false;
  }
  if (has_cleanerchatreplymessage()) {
    if (!this->cleanerchatreplymessage().IsInitialized()) return false;
  }
  return true;
}

void ChatCleanerMessage::Swap(ChatCleanerMessage* other) {
  if (other != this) {
    std::swap(messagetype_, other->messagetype_);
    std::swap(cleanerinitmessage_, other->cleanerinitmessage_);
    std::swap(cleanerinitackmessage_, other->cleanerinitackmessage_);
    std::swap(cleanerchatrequestmessage_, other->cleanerchatrequestmessage_);
    std::swap(cleanerchatreplymessage_, other->cleanerchatreplymessage_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string ChatCleanerMessage::GetTypeName() const {
  return "ChatCleanerMessage";
}


// @@protoc_insertion_point(namespace_scope)

// @@protoc_insertion_point(global_scope)
