zhuyujia-webhopper/collector/adg-linux/gen/google_apis/gcm/protocol/mcs.pb.cc

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

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

#include <algorithm>

#include <google/protobuf/stubs/common.h>
#include <google/protobuf/stubs/port.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/io/zero_copy_stream_impl_lite.h>
// @@protoc_insertion_point(includes)

namespace mcs_proto {
class HeartbeatPingDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<HeartbeatPing> {
} _HeartbeatPing_default_instance_;
class HeartbeatAckDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<HeartbeatAck> {
} _HeartbeatAck_default_instance_;
class ErrorInfoDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<ErrorInfo> {
} _ErrorInfo_default_instance_;
class SettingDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<Setting> {
} _Setting_default_instance_;
class HeartbeatStatDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<HeartbeatStat> {
} _HeartbeatStat_default_instance_;
class HeartbeatConfigDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<HeartbeatConfig> {
} _HeartbeatConfig_default_instance_;
class ClientEventDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<ClientEvent> {
} _ClientEvent_default_instance_;
class LoginRequestDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<LoginRequest> {
} _LoginRequest_default_instance_;
class LoginResponseDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<LoginResponse> {
} _LoginResponse_default_instance_;
class StreamErrorStanzaDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<StreamErrorStanza> {
} _StreamErrorStanza_default_instance_;
class CloseDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<Close> {
} _Close_default_instance_;
class ExtensionDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<Extension> {
} _Extension_default_instance_;
class IqStanzaDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<IqStanza> {
} _IqStanza_default_instance_;
class AppDataDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<AppData> {
} _AppData_default_instance_;
class DataMessageStanzaDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<DataMessageStanza> {
} _DataMessageStanza_default_instance_;
class StreamAckDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<StreamAck> {
} _StreamAck_default_instance_;
class SelectiveAckDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<SelectiveAck> {
} _SelectiveAck_default_instance_;

namespace protobuf_mcs_2eproto {

PROTOBUF_CONSTEXPR_VAR ::google::protobuf::internal::ParseTableField
    const TableStruct::entries[] = {
  {0, 0, 0, ::google::protobuf::internal::kInvalidMask, 0, 0},
};

PROTOBUF_CONSTEXPR_VAR ::google::protobuf::internal::AuxillaryParseTableField
    const TableStruct::aux[] = {
  ::google::protobuf::internal::AuxillaryParseTableField(),
};
PROTOBUF_CONSTEXPR_VAR ::google::protobuf::internal::ParseTable const
    TableStruct::schema[] = {
  { NULL, NULL, 0, -1, -1, false },
  { NULL, NULL, 0, -1, -1, false },
  { NULL, NULL, 0, -1, -1, false },
  { NULL, NULL, 0, -1, -1, false },
  { NULL, NULL, 0, -1, -1, false },
  { NULL, NULL, 0, -1, -1, false },
  { NULL, NULL, 0, -1, -1, false },
  { NULL, NULL, 0, -1, -1, false },
  { NULL, NULL, 0, -1, -1, false },
  { NULL, NULL, 0, -1, -1, false },
  { NULL, NULL, 0, -1, -1, false },
  { NULL, NULL, 0, -1, -1, false },
  { NULL, NULL, 0, -1, -1, false },
  { NULL, NULL, 0, -1, -1, false },
  { NULL, NULL, 0, -1, -1, false },
  { NULL, NULL, 0, -1, -1, false },
  { NULL, NULL, 0, -1, -1, false },
};


void TableStruct::Shutdown() {
  _HeartbeatPing_default_instance_.Shutdown();
  _HeartbeatAck_default_instance_.Shutdown();
  _ErrorInfo_default_instance_.Shutdown();
  _Setting_default_instance_.Shutdown();
  _HeartbeatStat_default_instance_.Shutdown();
  _HeartbeatConfig_default_instance_.Shutdown();
  _ClientEvent_default_instance_.Shutdown();
  _LoginRequest_default_instance_.Shutdown();
  _LoginResponse_default_instance_.Shutdown();
  _StreamErrorStanza_default_instance_.Shutdown();
  _Close_default_instance_.Shutdown();
  _Extension_default_instance_.Shutdown();
  _IqStanza_default_instance_.Shutdown();
  _AppData_default_instance_.Shutdown();
  _DataMessageStanza_default_instance_.Shutdown();
  _StreamAck_default_instance_.Shutdown();
  _SelectiveAck_default_instance_.Shutdown();
}

void TableStruct::InitDefaultsImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  ::google::protobuf::internal::InitProtobufDefaults();
  _HeartbeatPing_default_instance_.DefaultConstruct();
  _HeartbeatAck_default_instance_.DefaultConstruct();
  _ErrorInfo_default_instance_.DefaultConstruct();
  _Setting_default_instance_.DefaultConstruct();
  _HeartbeatStat_default_instance_.DefaultConstruct();
  _HeartbeatConfig_default_instance_.DefaultConstruct();
  _ClientEvent_default_instance_.DefaultConstruct();
  _LoginRequest_default_instance_.DefaultConstruct();
  _LoginResponse_default_instance_.DefaultConstruct();
  _StreamErrorStanza_default_instance_.DefaultConstruct();
  _Close_default_instance_.DefaultConstruct();
  _Extension_default_instance_.DefaultConstruct();
  _IqStanza_default_instance_.DefaultConstruct();
  _AppData_default_instance_.DefaultConstruct();
  _DataMessageStanza_default_instance_.DefaultConstruct();
  _StreamAck_default_instance_.DefaultConstruct();
  _SelectiveAck_default_instance_.DefaultConstruct();
  _ErrorInfo_default_instance_.get_mutable()->extension_ = const_cast< ::mcs_proto::Extension*>(
      ::mcs_proto::Extension::internal_default_instance());
  _LoginRequest_default_instance_.get_mutable()->heartbeat_stat_ = const_cast< ::mcs_proto::HeartbeatStat*>(
      ::mcs_proto::HeartbeatStat::internal_default_instance());
  _LoginResponse_default_instance_.get_mutable()->error_ = const_cast< ::mcs_proto::ErrorInfo*>(
      ::mcs_proto::ErrorInfo::internal_default_instance());
  _LoginResponse_default_instance_.get_mutable()->heartbeat_config_ = const_cast< ::mcs_proto::HeartbeatConfig*>(
      ::mcs_proto::HeartbeatConfig::internal_default_instance());
  _IqStanza_default_instance_.get_mutable()->error_ = const_cast< ::mcs_proto::ErrorInfo*>(
      ::mcs_proto::ErrorInfo::internal_default_instance());
  _IqStanza_default_instance_.get_mutable()->extension_ = const_cast< ::mcs_proto::Extension*>(
      ::mcs_proto::Extension::internal_default_instance());
}

void InitDefaults() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &TableStruct::InitDefaultsImpl);
}
void AddDescriptorsImpl() {
  InitDefaults();
  ::google::protobuf::internal::OnShutdown(&TableStruct::Shutdown);
}

void AddDescriptors() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &AddDescriptorsImpl);
}

}  // namespace protobuf_mcs_2eproto

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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const ClientEvent_Type ClientEvent::UNKNOWN;
const ClientEvent_Type ClientEvent::DISCARDED_EVENTS;
const ClientEvent_Type ClientEvent::FAILED_CONNECTION;
const ClientEvent_Type ClientEvent::SUCCESSFUL_CONNECTION;
const ClientEvent_Type ClientEvent::Type_MIN;
const ClientEvent_Type ClientEvent::Type_MAX;
const int ClientEvent::Type_ARRAYSIZE;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
bool LoginRequest_AuthService_IsValid(int value) {
  switch (value) {
    case 2:
      return true;
    default:
      return false;
  }
}

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const LoginRequest_AuthService LoginRequest::ANDROID_ID;
const LoginRequest_AuthService LoginRequest::AuthService_MIN;
const LoginRequest_AuthService LoginRequest::AuthService_MAX;
const int LoginRequest::AuthService_ARRAYSIZE;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
bool IqStanza_IqType_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
      return true;
    default:
      return false;
  }
}

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const IqStanza_IqType IqStanza::GET;
const IqStanza_IqType IqStanza::SET;
const IqStanza_IqType IqStanza::RESULT;
const IqStanza_IqType IqStanza::IQ_ERROR;
const IqStanza_IqType IqStanza::IqType_MIN;
const IqStanza_IqType IqStanza::IqType_MAX;
const int IqStanza::IqType_ARRAYSIZE;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int HeartbeatPing::kStreamIdFieldNumber;
const int HeartbeatPing::kLastStreamIdReceivedFieldNumber;
const int HeartbeatPing::kStatusFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

HeartbeatPing::HeartbeatPing()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_mcs_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:mcs_proto.HeartbeatPing)
}
HeartbeatPing::HeartbeatPing(const HeartbeatPing& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&stream_id_, &from.stream_id_,
    static_cast<size_t>(reinterpret_cast<char*>(&status_) -
    reinterpret_cast<char*>(&stream_id_)) + sizeof(status_));
  // @@protoc_insertion_point(copy_constructor:mcs_proto.HeartbeatPing)
}

void HeartbeatPing::SharedCtor() {
  _cached_size_ = 0;
  ::memset(&stream_id_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&status_) -
      reinterpret_cast<char*>(&stream_id_)) + sizeof(status_));
}

HeartbeatPing::~HeartbeatPing() {
  // @@protoc_insertion_point(destructor:mcs_proto.HeartbeatPing)
  SharedDtor();
}

void HeartbeatPing::SharedDtor() {
}

void HeartbeatPing::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const HeartbeatPing& HeartbeatPing::default_instance() {
  protobuf_mcs_2eproto::InitDefaults();
  return *internal_default_instance();
}

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

void HeartbeatPing::Clear() {
// @@protoc_insertion_point(message_clear_start:mcs_proto.HeartbeatPing)
  if (_has_bits_[0 / 32] & 7u) {
    ::memset(&stream_id_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&status_) -
        reinterpret_cast<char*>(&stream_id_)) + sizeof(status_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool HeartbeatPing::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:mcs_proto.HeartbeatPing)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 stream_id = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u)) {
          set_has_stream_id();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &stream_id_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 last_stream_id_received = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u)) {
          set_has_last_stream_id_received();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &last_stream_id_received_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int64 status = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(24u)) {
          set_has_status();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &status_)));
        } else {
          goto handle_unusual;
        }
        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::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:mcs_proto.HeartbeatPing)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:mcs_proto.HeartbeatPing)
  return false;
#undef DO_
}

void HeartbeatPing::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:mcs_proto.HeartbeatPing)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 stream_id = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->stream_id(), output);
  }

  // optional int32 last_stream_id_received = 2;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->last_stream_id_received(), output);
  }

  // optional int64 status = 3;
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(3, this->status(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:mcs_proto.HeartbeatPing)
}

size_t HeartbeatPing::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:mcs_proto.HeartbeatPing)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  if (_has_bits_[0 / 32] & 7u) {
    // optional int32 stream_id = 1;
    if (has_stream_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->stream_id());
    }

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

    // optional int64 status = 3;
    if (has_status()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->status());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

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

void HeartbeatPing::MergeFrom(const HeartbeatPing& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:mcs_proto.HeartbeatPing)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 7u) {
    if (cached_has_bits & 0x00000001u) {
      stream_id_ = from.stream_id_;
    }
    if (cached_has_bits & 0x00000002u) {
      last_stream_id_received_ = from.last_stream_id_received_;
    }
    if (cached_has_bits & 0x00000004u) {
      status_ = from.status_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void HeartbeatPing::CopyFrom(const HeartbeatPing& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:mcs_proto.HeartbeatPing)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool HeartbeatPing::IsInitialized() const {
  return true;
}

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

::std::string HeartbeatPing::GetTypeName() const {
  return "mcs_proto.HeartbeatPing";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// HeartbeatPing

// optional int32 stream_id = 1;
bool HeartbeatPing::has_stream_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void HeartbeatPing::set_has_stream_id() {
  _has_bits_[0] |= 0x00000001u;
}
void HeartbeatPing::clear_has_stream_id() {
  _has_bits_[0] &= ~0x00000001u;
}
void HeartbeatPing::clear_stream_id() {
  stream_id_ = 0;
  clear_has_stream_id();
}
::google::protobuf::int32 HeartbeatPing::stream_id() const {
  // @@protoc_insertion_point(field_get:mcs_proto.HeartbeatPing.stream_id)
  return stream_id_;
}
void HeartbeatPing::set_stream_id(::google::protobuf::int32 value) {
  set_has_stream_id();
  stream_id_ = value;
  // @@protoc_insertion_point(field_set:mcs_proto.HeartbeatPing.stream_id)
}

// optional int32 last_stream_id_received = 2;
bool HeartbeatPing::has_last_stream_id_received() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void HeartbeatPing::set_has_last_stream_id_received() {
  _has_bits_[0] |= 0x00000002u;
}
void HeartbeatPing::clear_has_last_stream_id_received() {
  _has_bits_[0] &= ~0x00000002u;
}
void HeartbeatPing::clear_last_stream_id_received() {
  last_stream_id_received_ = 0;
  clear_has_last_stream_id_received();
}
::google::protobuf::int32 HeartbeatPing::last_stream_id_received() const {
  // @@protoc_insertion_point(field_get:mcs_proto.HeartbeatPing.last_stream_id_received)
  return last_stream_id_received_;
}
void HeartbeatPing::set_last_stream_id_received(::google::protobuf::int32 value) {
  set_has_last_stream_id_received();
  last_stream_id_received_ = value;
  // @@protoc_insertion_point(field_set:mcs_proto.HeartbeatPing.last_stream_id_received)
}

// optional int64 status = 3;
bool HeartbeatPing::has_status() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
void HeartbeatPing::set_has_status() {
  _has_bits_[0] |= 0x00000004u;
}
void HeartbeatPing::clear_has_status() {
  _has_bits_[0] &= ~0x00000004u;
}
void HeartbeatPing::clear_status() {
  status_ = GOOGLE_LONGLONG(0);
  clear_has_status();
}
::google::protobuf::int64 HeartbeatPing::status() const {
  // @@protoc_insertion_point(field_get:mcs_proto.HeartbeatPing.status)
  return status_;
}
void HeartbeatPing::set_status(::google::protobuf::int64 value) {
  set_has_status();
  status_ = value;
  // @@protoc_insertion_point(field_set:mcs_proto.HeartbeatPing.status)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int HeartbeatAck::kStreamIdFieldNumber;
const int HeartbeatAck::kLastStreamIdReceivedFieldNumber;
const int HeartbeatAck::kStatusFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

HeartbeatAck::HeartbeatAck()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_mcs_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:mcs_proto.HeartbeatAck)
}
HeartbeatAck::HeartbeatAck(const HeartbeatAck& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&stream_id_, &from.stream_id_,
    static_cast<size_t>(reinterpret_cast<char*>(&status_) -
    reinterpret_cast<char*>(&stream_id_)) + sizeof(status_));
  // @@protoc_insertion_point(copy_constructor:mcs_proto.HeartbeatAck)
}

void HeartbeatAck::SharedCtor() {
  _cached_size_ = 0;
  ::memset(&stream_id_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&status_) -
      reinterpret_cast<char*>(&stream_id_)) + sizeof(status_));
}

HeartbeatAck::~HeartbeatAck() {
  // @@protoc_insertion_point(destructor:mcs_proto.HeartbeatAck)
  SharedDtor();
}

void HeartbeatAck::SharedDtor() {
}

void HeartbeatAck::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const HeartbeatAck& HeartbeatAck::default_instance() {
  protobuf_mcs_2eproto::InitDefaults();
  return *internal_default_instance();
}

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

void HeartbeatAck::Clear() {
// @@protoc_insertion_point(message_clear_start:mcs_proto.HeartbeatAck)
  if (_has_bits_[0 / 32] & 7u) {
    ::memset(&stream_id_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&status_) -
        reinterpret_cast<char*>(&stream_id_)) + sizeof(status_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool HeartbeatAck::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:mcs_proto.HeartbeatAck)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 stream_id = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u)) {
          set_has_stream_id();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &stream_id_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 last_stream_id_received = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u)) {
          set_has_last_stream_id_received();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &last_stream_id_received_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int64 status = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(24u)) {
          set_has_status();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &status_)));
        } else {
          goto handle_unusual;
        }
        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::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:mcs_proto.HeartbeatAck)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:mcs_proto.HeartbeatAck)
  return false;
#undef DO_
}

void HeartbeatAck::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:mcs_proto.HeartbeatAck)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 stream_id = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->stream_id(), output);
  }

  // optional int32 last_stream_id_received = 2;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->last_stream_id_received(), output);
  }

  // optional int64 status = 3;
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(3, this->status(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:mcs_proto.HeartbeatAck)
}

size_t HeartbeatAck::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:mcs_proto.HeartbeatAck)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  if (_has_bits_[0 / 32] & 7u) {
    // optional int32 stream_id = 1;
    if (has_stream_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->stream_id());
    }

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

    // optional int64 status = 3;
    if (has_status()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->status());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

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

void HeartbeatAck::MergeFrom(const HeartbeatAck& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:mcs_proto.HeartbeatAck)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 7u) {
    if (cached_has_bits & 0x00000001u) {
      stream_id_ = from.stream_id_;
    }
    if (cached_has_bits & 0x00000002u) {
      last_stream_id_received_ = from.last_stream_id_received_;
    }
    if (cached_has_bits & 0x00000004u) {
      status_ = from.status_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void HeartbeatAck::CopyFrom(const HeartbeatAck& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:mcs_proto.HeartbeatAck)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool HeartbeatAck::IsInitialized() const {
  return true;
}

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

::std::string HeartbeatAck::GetTypeName() const {
  return "mcs_proto.HeartbeatAck";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// HeartbeatAck

// optional int32 stream_id = 1;
bool HeartbeatAck::has_stream_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void HeartbeatAck::set_has_stream_id() {
  _has_bits_[0] |= 0x00000001u;
}
void HeartbeatAck::clear_has_stream_id() {
  _has_bits_[0] &= ~0x00000001u;
}
void HeartbeatAck::clear_stream_id() {
  stream_id_ = 0;
  clear_has_stream_id();
}
::google::protobuf::int32 HeartbeatAck::stream_id() const {
  // @@protoc_insertion_point(field_get:mcs_proto.HeartbeatAck.stream_id)
  return stream_id_;
}
void HeartbeatAck::set_stream_id(::google::protobuf::int32 value) {
  set_has_stream_id();
  stream_id_ = value;
  // @@protoc_insertion_point(field_set:mcs_proto.HeartbeatAck.stream_id)
}

// optional int32 last_stream_id_received = 2;
bool HeartbeatAck::has_last_stream_id_received() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void HeartbeatAck::set_has_last_stream_id_received() {
  _has_bits_[0] |= 0x00000002u;
}
void HeartbeatAck::clear_has_last_stream_id_received() {
  _has_bits_[0] &= ~0x00000002u;
}
void HeartbeatAck::clear_last_stream_id_received() {
  last_stream_id_received_ = 0;
  clear_has_last_stream_id_received();
}
::google::protobuf::int32 HeartbeatAck::last_stream_id_received() const {
  // @@protoc_insertion_point(field_get:mcs_proto.HeartbeatAck.last_stream_id_received)
  return last_stream_id_received_;
}
void HeartbeatAck::set_last_stream_id_received(::google::protobuf::int32 value) {
  set_has_last_stream_id_received();
  last_stream_id_received_ = value;
  // @@protoc_insertion_point(field_set:mcs_proto.HeartbeatAck.last_stream_id_received)
}

// optional int64 status = 3;
bool HeartbeatAck::has_status() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
void HeartbeatAck::set_has_status() {
  _has_bits_[0] |= 0x00000004u;
}
void HeartbeatAck::clear_has_status() {
  _has_bits_[0] &= ~0x00000004u;
}
void HeartbeatAck::clear_status() {
  status_ = GOOGLE_LONGLONG(0);
  clear_has_status();
}
::google::protobuf::int64 HeartbeatAck::status() const {
  // @@protoc_insertion_point(field_get:mcs_proto.HeartbeatAck.status)
  return status_;
}
void HeartbeatAck::set_status(::google::protobuf::int64 value) {
  set_has_status();
  status_ = value;
  // @@protoc_insertion_point(field_set:mcs_proto.HeartbeatAck.status)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int ErrorInfo::kCodeFieldNumber;
const int ErrorInfo::kMessageFieldNumber;
const int ErrorInfo::kTypeFieldNumber;
const int ErrorInfo::kExtensionFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

ErrorInfo::ErrorInfo()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_mcs_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:mcs_proto.ErrorInfo)
}
ErrorInfo::ErrorInfo(const ErrorInfo& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  message_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_message()) {
    message_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.message_);
  }
  type_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_type()) {
    type_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.type_);
  }
  if (from.has_extension()) {
    extension_ = new ::mcs_proto::Extension(*from.extension_);
  } else {
    extension_ = NULL;
  }
  code_ = from.code_;
  // @@protoc_insertion_point(copy_constructor:mcs_proto.ErrorInfo)
}

void ErrorInfo::SharedCtor() {
  _cached_size_ = 0;
  message_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  type_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(&extension_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&code_) -
      reinterpret_cast<char*>(&extension_)) + sizeof(code_));
}

ErrorInfo::~ErrorInfo() {
  // @@protoc_insertion_point(destructor:mcs_proto.ErrorInfo)
  SharedDtor();
}

void ErrorInfo::SharedDtor() {
  message_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  type_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (this != internal_default_instance()) {
    delete extension_;
  }
}

void ErrorInfo::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ErrorInfo& ErrorInfo::default_instance() {
  protobuf_mcs_2eproto::InitDefaults();
  return *internal_default_instance();
}

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

void ErrorInfo::Clear() {
// @@protoc_insertion_point(message_clear_start:mcs_proto.ErrorInfo)
  if (_has_bits_[0 / 32] & 7u) {
    if (has_message()) {
      GOOGLE_DCHECK(!message_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*message_.UnsafeRawStringPointer())->clear();
    }
    if (has_type()) {
      GOOGLE_DCHECK(!type_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*type_.UnsafeRawStringPointer())->clear();
    }
    if (has_extension()) {
      GOOGLE_DCHECK(extension_ != NULL);
      extension_->::mcs_proto::Extension::Clear();
    }
  }
  code_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool ErrorInfo::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:mcs_proto.ErrorInfo)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required int32 code = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u)) {
          set_has_code();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &code_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional string message = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(18u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_message()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional string type = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(26u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_type()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .mcs_proto.Extension extension = 4;
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(34u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_extension()));
        } else {
          goto handle_unusual;
        }
        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::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:mcs_proto.ErrorInfo)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:mcs_proto.ErrorInfo)
  return false;
#undef DO_
}

void ErrorInfo::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:mcs_proto.ErrorInfo)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required int32 code = 1;
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->code(), output);
  }

  // optional string message = 2;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      2, this->message(), output);
  }

  // optional string type = 3;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      3, this->type(), output);
  }

  // optional .mcs_proto.Extension extension = 4;
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      4, *this->extension_, output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:mcs_proto.ErrorInfo)
}

size_t ErrorInfo::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:mcs_proto.ErrorInfo)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  // required int32 code = 1;
  if (has_code()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int32Size(
        this->code());
  }
  if (_has_bits_[0 / 32] & 7u) {
    // optional string message = 2;
    if (has_message()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->message());
    }

    // optional string type = 3;
    if (has_type()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->type());
    }

    // optional .mcs_proto.Extension extension = 4;
    if (has_extension()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *this->extension_);
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

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

void ErrorInfo::MergeFrom(const ErrorInfo& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:mcs_proto.ErrorInfo)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 15u) {
    if (cached_has_bits & 0x00000001u) {
      set_has_message();
      message_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.message_);
    }
    if (cached_has_bits & 0x00000002u) {
      set_has_type();
      type_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.type_);
    }
    if (cached_has_bits & 0x00000004u) {
      mutable_extension()->::mcs_proto::Extension::MergeFrom(from.extension());
    }
    if (cached_has_bits & 0x00000008u) {
      code_ = from.code_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void ErrorInfo::CopyFrom(const ErrorInfo& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:mcs_proto.ErrorInfo)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ErrorInfo::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000008) != 0x00000008) return false;
  if (has_extension()) {
    if (!this->extension_->IsInitialized()) return false;
  }
  return true;
}

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

::std::string ErrorInfo::GetTypeName() const {
  return "mcs_proto.ErrorInfo";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// ErrorInfo

// required int32 code = 1;
bool ErrorInfo::has_code() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
void ErrorInfo::set_has_code() {
  _has_bits_[0] |= 0x00000008u;
}
void ErrorInfo::clear_has_code() {
  _has_bits_[0] &= ~0x00000008u;
}
void ErrorInfo::clear_code() {
  code_ = 0;
  clear_has_code();
}
::google::protobuf::int32 ErrorInfo::code() const {
  // @@protoc_insertion_point(field_get:mcs_proto.ErrorInfo.code)
  return code_;
}
void ErrorInfo::set_code(::google::protobuf::int32 value) {
  set_has_code();
  code_ = value;
  // @@protoc_insertion_point(field_set:mcs_proto.ErrorInfo.code)
}

// optional string message = 2;
bool ErrorInfo::has_message() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void ErrorInfo::set_has_message() {
  _has_bits_[0] |= 0x00000001u;
}
void ErrorInfo::clear_has_message() {
  _has_bits_[0] &= ~0x00000001u;
}
void ErrorInfo::clear_message() {
  message_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_message();
}
const ::std::string& ErrorInfo::message() const {
  // @@protoc_insertion_point(field_get:mcs_proto.ErrorInfo.message)
  return message_.GetNoArena();
}
void ErrorInfo::set_message(const ::std::string& value) {
  set_has_message();
  message_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:mcs_proto.ErrorInfo.message)
}
#if LANG_CXX11
void ErrorInfo::set_message(::std::string&& value) {
  set_has_message();
  message_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:mcs_proto.ErrorInfo.message)
}
#endif
void ErrorInfo::set_message(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_message();
  message_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:mcs_proto.ErrorInfo.message)
}
void ErrorInfo::set_message(const char* value, size_t size) {
  set_has_message();
  message_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:mcs_proto.ErrorInfo.message)
}
::std::string* ErrorInfo::mutable_message() {
  set_has_message();
  // @@protoc_insertion_point(field_mutable:mcs_proto.ErrorInfo.message)
  return message_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* ErrorInfo::release_message() {
  // @@protoc_insertion_point(field_release:mcs_proto.ErrorInfo.message)
  clear_has_message();
  return message_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void ErrorInfo::set_allocated_message(::std::string* message) {
  if (message != NULL) {
    set_has_message();
  } else {
    clear_has_message();
  }
  message_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), message);
  // @@protoc_insertion_point(field_set_allocated:mcs_proto.ErrorInfo.message)
}

// optional string type = 3;
bool ErrorInfo::has_type() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void ErrorInfo::set_has_type() {
  _has_bits_[0] |= 0x00000002u;
}
void ErrorInfo::clear_has_type() {
  _has_bits_[0] &= ~0x00000002u;
}
void ErrorInfo::clear_type() {
  type_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_type();
}
const ::std::string& ErrorInfo::type() const {
  // @@protoc_insertion_point(field_get:mcs_proto.ErrorInfo.type)
  return type_.GetNoArena();
}
void ErrorInfo::set_type(const ::std::string& value) {
  set_has_type();
  type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:mcs_proto.ErrorInfo.type)
}
#if LANG_CXX11
void ErrorInfo::set_type(::std::string&& value) {
  set_has_type();
  type_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:mcs_proto.ErrorInfo.type)
}
#endif
void ErrorInfo::set_type(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_type();
  type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:mcs_proto.ErrorInfo.type)
}
void ErrorInfo::set_type(const char* value, size_t size) {
  set_has_type();
  type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:mcs_proto.ErrorInfo.type)
}
::std::string* ErrorInfo::mutable_type() {
  set_has_type();
  // @@protoc_insertion_point(field_mutable:mcs_proto.ErrorInfo.type)
  return type_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* ErrorInfo::release_type() {
  // @@protoc_insertion_point(field_release:mcs_proto.ErrorInfo.type)
  clear_has_type();
  return type_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void ErrorInfo::set_allocated_type(::std::string* type) {
  if (type != NULL) {
    set_has_type();
  } else {
    clear_has_type();
  }
  type_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), type);
  // @@protoc_insertion_point(field_set_allocated:mcs_proto.ErrorInfo.type)
}

// optional .mcs_proto.Extension extension = 4;
bool ErrorInfo::has_extension() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
void ErrorInfo::set_has_extension() {
  _has_bits_[0] |= 0x00000004u;
}
void ErrorInfo::clear_has_extension() {
  _has_bits_[0] &= ~0x00000004u;
}
void ErrorInfo::clear_extension() {
  if (extension_ != NULL) extension_->::mcs_proto::Extension::Clear();
  clear_has_extension();
}
const ::mcs_proto::Extension& ErrorInfo::extension() const {
  // @@protoc_insertion_point(field_get:mcs_proto.ErrorInfo.extension)
  return extension_ != NULL ? *extension_
                         : *::mcs_proto::Extension::internal_default_instance();
}
::mcs_proto::Extension* ErrorInfo::mutable_extension() {
  set_has_extension();
  if (extension_ == NULL) {
    extension_ = new ::mcs_proto::Extension;
  }
  // @@protoc_insertion_point(field_mutable:mcs_proto.ErrorInfo.extension)
  return extension_;
}
::mcs_proto::Extension* ErrorInfo::release_extension() {
  // @@protoc_insertion_point(field_release:mcs_proto.ErrorInfo.extension)
  clear_has_extension();
  ::mcs_proto::Extension* temp = extension_;
  extension_ = NULL;
  return temp;
}
void ErrorInfo::set_allocated_extension(::mcs_proto::Extension* extension) {
  delete extension_;
  extension_ = extension;
  if (extension) {
    set_has_extension();
  } else {
    clear_has_extension();
  }
  // @@protoc_insertion_point(field_set_allocated:mcs_proto.ErrorInfo.extension)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int Setting::kNameFieldNumber;
const int Setting::kValueFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

Setting::Setting()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_mcs_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:mcs_proto.Setting)
}
Setting::Setting(const Setting& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_name()) {
    name_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.name_);
  }
  value_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_value()) {
    value_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.value_);
  }
  // @@protoc_insertion_point(copy_constructor:mcs_proto.Setting)
}

void Setting::SharedCtor() {
  _cached_size_ = 0;
  name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  value_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}

Setting::~Setting() {
  // @@protoc_insertion_point(destructor:mcs_proto.Setting)
  SharedDtor();
}

void Setting::SharedDtor() {
  name_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  value_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}

void Setting::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const Setting& Setting::default_instance() {
  protobuf_mcs_2eproto::InitDefaults();
  return *internal_default_instance();
}

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

void Setting::Clear() {
// @@protoc_insertion_point(message_clear_start:mcs_proto.Setting)
  if (_has_bits_[0 / 32] & 3u) {
    if (has_name()) {
      GOOGLE_DCHECK(!name_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*name_.UnsafeRawStringPointer())->clear();
    }
    if (has_value()) {
      GOOGLE_DCHECK(!value_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*value_.UnsafeRawStringPointer())->clear();
    }
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool Setting::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:mcs_proto.Setting)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required string name = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_name()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // required string value = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(18u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_value()));
        } else {
          goto handle_unusual;
        }
        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::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:mcs_proto.Setting)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:mcs_proto.Setting)
  return false;
#undef DO_
}

void Setting::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:mcs_proto.Setting)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required string name = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->name(), output);
  }

  // required string value = 2;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      2, this->value(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:mcs_proto.Setting)
}

size_t Setting::RequiredFieldsByteSizeFallback() const {
// @@protoc_insertion_point(required_fields_byte_size_fallback_start:mcs_proto.Setting)
  size_t total_size = 0;

  if (has_name()) {
    // required string name = 1;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::StringSize(
        this->name());
  }

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

  return total_size;
}
size_t Setting::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:mcs_proto.Setting)
  size_t total_size = 0;

  total_size += unknown_fields().size();

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

    // required string value = 2;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::StringSize(
        this->value());

  } else {
    total_size += RequiredFieldsByteSizeFallback();
  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

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

void Setting::MergeFrom(const Setting& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:mcs_proto.Setting)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 3u) {
    if (cached_has_bits & 0x00000001u) {
      set_has_name();
      name_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.name_);
    }
    if (cached_has_bits & 0x00000002u) {
      set_has_value();
      value_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.value_);
    }
  }
}

void Setting::CopyFrom(const Setting& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:mcs_proto.Setting)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

::std::string Setting::GetTypeName() const {
  return "mcs_proto.Setting";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// Setting

// required string name = 1;
bool Setting::has_name() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void Setting::set_has_name() {
  _has_bits_[0] |= 0x00000001u;
}
void Setting::clear_has_name() {
  _has_bits_[0] &= ~0x00000001u;
}
void Setting::clear_name() {
  name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_name();
}
const ::std::string& Setting::name() const {
  // @@protoc_insertion_point(field_get:mcs_proto.Setting.name)
  return name_.GetNoArena();
}
void Setting::set_name(const ::std::string& value) {
  set_has_name();
  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:mcs_proto.Setting.name)
}
#if LANG_CXX11
void Setting::set_name(::std::string&& value) {
  set_has_name();
  name_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:mcs_proto.Setting.name)
}
#endif
void Setting::set_name(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_name();
  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:mcs_proto.Setting.name)
}
void Setting::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:mcs_proto.Setting.name)
}
::std::string* Setting::mutable_name() {
  set_has_name();
  // @@protoc_insertion_point(field_mutable:mcs_proto.Setting.name)
  return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* Setting::release_name() {
  // @@protoc_insertion_point(field_release:mcs_proto.Setting.name)
  clear_has_name();
  return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void Setting::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:mcs_proto.Setting.name)
}

// required string value = 2;
bool Setting::has_value() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void Setting::set_has_value() {
  _has_bits_[0] |= 0x00000002u;
}
void Setting::clear_has_value() {
  _has_bits_[0] &= ~0x00000002u;
}
void Setting::clear_value() {
  value_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_value();
}
const ::std::string& Setting::value() const {
  // @@protoc_insertion_point(field_get:mcs_proto.Setting.value)
  return value_.GetNoArena();
}
void Setting::set_value(const ::std::string& value) {
  set_has_value();
  value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:mcs_proto.Setting.value)
}
#if LANG_CXX11
void Setting::set_value(::std::string&& value) {
  set_has_value();
  value_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:mcs_proto.Setting.value)
}
#endif
void Setting::set_value(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_value();
  value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:mcs_proto.Setting.value)
}
void Setting::set_value(const char* value, size_t size) {
  set_has_value();
  value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:mcs_proto.Setting.value)
}
::std::string* Setting::mutable_value() {
  set_has_value();
  // @@protoc_insertion_point(field_mutable:mcs_proto.Setting.value)
  return value_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* Setting::release_value() {
  // @@protoc_insertion_point(field_release:mcs_proto.Setting.value)
  clear_has_value();
  return value_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void Setting::set_allocated_value(::std::string* value) {
  if (value != NULL) {
    set_has_value();
  } else {
    clear_has_value();
  }
  value_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set_allocated:mcs_proto.Setting.value)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int HeartbeatStat::kIpFieldNumber;
const int HeartbeatStat::kTimeoutFieldNumber;
const int HeartbeatStat::kIntervalMsFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

HeartbeatStat::HeartbeatStat()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_mcs_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:mcs_proto.HeartbeatStat)
}
HeartbeatStat::HeartbeatStat(const HeartbeatStat& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ip_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_ip()) {
    ip_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.ip_);
  }
  ::memcpy(&timeout_, &from.timeout_,
    static_cast<size_t>(reinterpret_cast<char*>(&interval_ms_) -
    reinterpret_cast<char*>(&timeout_)) + sizeof(interval_ms_));
  // @@protoc_insertion_point(copy_constructor:mcs_proto.HeartbeatStat)
}

void HeartbeatStat::SharedCtor() {
  _cached_size_ = 0;
  ip_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(&timeout_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&interval_ms_) -
      reinterpret_cast<char*>(&timeout_)) + sizeof(interval_ms_));
}

HeartbeatStat::~HeartbeatStat() {
  // @@protoc_insertion_point(destructor:mcs_proto.HeartbeatStat)
  SharedDtor();
}

void HeartbeatStat::SharedDtor() {
  ip_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}

void HeartbeatStat::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const HeartbeatStat& HeartbeatStat::default_instance() {
  protobuf_mcs_2eproto::InitDefaults();
  return *internal_default_instance();
}

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

void HeartbeatStat::Clear() {
// @@protoc_insertion_point(message_clear_start:mcs_proto.HeartbeatStat)
  if (has_ip()) {
    GOOGLE_DCHECK(!ip_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
    (*ip_.UnsafeRawStringPointer())->clear();
  }
  if (_has_bits_[0 / 32] & 6u) {
    ::memset(&timeout_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&interval_ms_) -
        reinterpret_cast<char*>(&timeout_)) + sizeof(interval_ms_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool HeartbeatStat::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:mcs_proto.HeartbeatStat)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required string ip = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_ip()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // required bool timeout = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u)) {
          set_has_timeout();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &timeout_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // required int32 interval_ms = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(24u)) {
          set_has_interval_ms();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &interval_ms_)));
        } else {
          goto handle_unusual;
        }
        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::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:mcs_proto.HeartbeatStat)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:mcs_proto.HeartbeatStat)
  return false;
#undef DO_
}

void HeartbeatStat::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:mcs_proto.HeartbeatStat)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required string ip = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->ip(), output);
  }

  // required bool timeout = 2;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->timeout(), output);
  }

  // required int32 interval_ms = 3;
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->interval_ms(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:mcs_proto.HeartbeatStat)
}

size_t HeartbeatStat::RequiredFieldsByteSizeFallback() const {
// @@protoc_insertion_point(required_fields_byte_size_fallback_start:mcs_proto.HeartbeatStat)
  size_t total_size = 0;

  if (has_ip()) {
    // required string ip = 1;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::StringSize(
        this->ip());
  }

  if (has_timeout()) {
    // required bool timeout = 2;
    total_size += 1 + 1;
  }

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

  return total_size;
}
size_t HeartbeatStat::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:mcs_proto.HeartbeatStat)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  if (((_has_bits_[0] & 0x00000007) ^ 0x00000007) == 0) {  // All required fields are present.
    // required string ip = 1;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::StringSize(
        this->ip());

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

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

  } else {
    total_size += RequiredFieldsByteSizeFallback();
  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

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

void HeartbeatStat::MergeFrom(const HeartbeatStat& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:mcs_proto.HeartbeatStat)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 7u) {
    if (cached_has_bits & 0x00000001u) {
      set_has_ip();
      ip_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.ip_);
    }
    if (cached_has_bits & 0x00000002u) {
      timeout_ = from.timeout_;
    }
    if (cached_has_bits & 0x00000004u) {
      interval_ms_ = from.interval_ms_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void HeartbeatStat::CopyFrom(const HeartbeatStat& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:mcs_proto.HeartbeatStat)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

::std::string HeartbeatStat::GetTypeName() const {
  return "mcs_proto.HeartbeatStat";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// HeartbeatStat

// required string ip = 1;
bool HeartbeatStat::has_ip() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void HeartbeatStat::set_has_ip() {
  _has_bits_[0] |= 0x00000001u;
}
void HeartbeatStat::clear_has_ip() {
  _has_bits_[0] &= ~0x00000001u;
}
void HeartbeatStat::clear_ip() {
  ip_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_ip();
}
const ::std::string& HeartbeatStat::ip() const {
  // @@protoc_insertion_point(field_get:mcs_proto.HeartbeatStat.ip)
  return ip_.GetNoArena();
}
void HeartbeatStat::set_ip(const ::std::string& value) {
  set_has_ip();
  ip_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:mcs_proto.HeartbeatStat.ip)
}
#if LANG_CXX11
void HeartbeatStat::set_ip(::std::string&& value) {
  set_has_ip();
  ip_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:mcs_proto.HeartbeatStat.ip)
}
#endif
void HeartbeatStat::set_ip(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_ip();
  ip_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:mcs_proto.HeartbeatStat.ip)
}
void HeartbeatStat::set_ip(const char* value, size_t size) {
  set_has_ip();
  ip_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:mcs_proto.HeartbeatStat.ip)
}
::std::string* HeartbeatStat::mutable_ip() {
  set_has_ip();
  // @@protoc_insertion_point(field_mutable:mcs_proto.HeartbeatStat.ip)
  return ip_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* HeartbeatStat::release_ip() {
  // @@protoc_insertion_point(field_release:mcs_proto.HeartbeatStat.ip)
  clear_has_ip();
  return ip_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void HeartbeatStat::set_allocated_ip(::std::string* ip) {
  if (ip != NULL) {
    set_has_ip();
  } else {
    clear_has_ip();
  }
  ip_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ip);
  // @@protoc_insertion_point(field_set_allocated:mcs_proto.HeartbeatStat.ip)
}

// required bool timeout = 2;
bool HeartbeatStat::has_timeout() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void HeartbeatStat::set_has_timeout() {
  _has_bits_[0] |= 0x00000002u;
}
void HeartbeatStat::clear_has_timeout() {
  _has_bits_[0] &= ~0x00000002u;
}
void HeartbeatStat::clear_timeout() {
  timeout_ = false;
  clear_has_timeout();
}
bool HeartbeatStat::timeout() const {
  // @@protoc_insertion_point(field_get:mcs_proto.HeartbeatStat.timeout)
  return timeout_;
}
void HeartbeatStat::set_timeout(bool value) {
  set_has_timeout();
  timeout_ = value;
  // @@protoc_insertion_point(field_set:mcs_proto.HeartbeatStat.timeout)
}

// required int32 interval_ms = 3;
bool HeartbeatStat::has_interval_ms() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
void HeartbeatStat::set_has_interval_ms() {
  _has_bits_[0] |= 0x00000004u;
}
void HeartbeatStat::clear_has_interval_ms() {
  _has_bits_[0] &= ~0x00000004u;
}
void HeartbeatStat::clear_interval_ms() {
  interval_ms_ = 0;
  clear_has_interval_ms();
}
::google::protobuf::int32 HeartbeatStat::interval_ms() const {
  // @@protoc_insertion_point(field_get:mcs_proto.HeartbeatStat.interval_ms)
  return interval_ms_;
}
void HeartbeatStat::set_interval_ms(::google::protobuf::int32 value) {
  set_has_interval_ms();
  interval_ms_ = value;
  // @@protoc_insertion_point(field_set:mcs_proto.HeartbeatStat.interval_ms)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int HeartbeatConfig::kUploadStatFieldNumber;
const int HeartbeatConfig::kIpFieldNumber;
const int HeartbeatConfig::kIntervalMsFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

HeartbeatConfig::HeartbeatConfig()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_mcs_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:mcs_proto.HeartbeatConfig)
}
HeartbeatConfig::HeartbeatConfig(const HeartbeatConfig& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ip_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_ip()) {
    ip_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.ip_);
  }
  ::memcpy(&upload_stat_, &from.upload_stat_,
    static_cast<size_t>(reinterpret_cast<char*>(&interval_ms_) -
    reinterpret_cast<char*>(&upload_stat_)) + sizeof(interval_ms_));
  // @@protoc_insertion_point(copy_constructor:mcs_proto.HeartbeatConfig)
}

void HeartbeatConfig::SharedCtor() {
  _cached_size_ = 0;
  ip_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(&upload_stat_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&interval_ms_) -
      reinterpret_cast<char*>(&upload_stat_)) + sizeof(interval_ms_));
}

HeartbeatConfig::~HeartbeatConfig() {
  // @@protoc_insertion_point(destructor:mcs_proto.HeartbeatConfig)
  SharedDtor();
}

void HeartbeatConfig::SharedDtor() {
  ip_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}

void HeartbeatConfig::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const HeartbeatConfig& HeartbeatConfig::default_instance() {
  protobuf_mcs_2eproto::InitDefaults();
  return *internal_default_instance();
}

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

void HeartbeatConfig::Clear() {
// @@protoc_insertion_point(message_clear_start:mcs_proto.HeartbeatConfig)
  if (has_ip()) {
    GOOGLE_DCHECK(!ip_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
    (*ip_.UnsafeRawStringPointer())->clear();
  }
  if (_has_bits_[0 / 32] & 6u) {
    ::memset(&upload_stat_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&interval_ms_) -
        reinterpret_cast<char*>(&upload_stat_)) + sizeof(interval_ms_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool HeartbeatConfig::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:mcs_proto.HeartbeatConfig)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional bool upload_stat = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u)) {
          set_has_upload_stat();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &upload_stat_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional string ip = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(18u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_ip()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 interval_ms = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(24u)) {
          set_has_interval_ms();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &interval_ms_)));
        } else {
          goto handle_unusual;
        }
        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::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:mcs_proto.HeartbeatConfig)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:mcs_proto.HeartbeatConfig)
  return false;
#undef DO_
}

void HeartbeatConfig::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:mcs_proto.HeartbeatConfig)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional bool upload_stat = 1;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->upload_stat(), output);
  }

  // optional string ip = 2;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      2, this->ip(), output);
  }

  // optional int32 interval_ms = 3;
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->interval_ms(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:mcs_proto.HeartbeatConfig)
}

size_t HeartbeatConfig::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:mcs_proto.HeartbeatConfig)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  if (_has_bits_[0 / 32] & 7u) {
    // optional string ip = 2;
    if (has_ip()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->ip());
    }

    // optional bool upload_stat = 1;
    if (has_upload_stat()) {
      total_size += 1 + 1;
    }

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

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

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

void HeartbeatConfig::MergeFrom(const HeartbeatConfig& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:mcs_proto.HeartbeatConfig)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 7u) {
    if (cached_has_bits & 0x00000001u) {
      set_has_ip();
      ip_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.ip_);
    }
    if (cached_has_bits & 0x00000002u) {
      upload_stat_ = from.upload_stat_;
    }
    if (cached_has_bits & 0x00000004u) {
      interval_ms_ = from.interval_ms_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void HeartbeatConfig::CopyFrom(const HeartbeatConfig& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:mcs_proto.HeartbeatConfig)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool HeartbeatConfig::IsInitialized() const {
  return true;
}

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

::std::string HeartbeatConfig::GetTypeName() const {
  return "mcs_proto.HeartbeatConfig";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// HeartbeatConfig

// optional bool upload_stat = 1;
bool HeartbeatConfig::has_upload_stat() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void HeartbeatConfig::set_has_upload_stat() {
  _has_bits_[0] |= 0x00000002u;
}
void HeartbeatConfig::clear_has_upload_stat() {
  _has_bits_[0] &= ~0x00000002u;
}
void HeartbeatConfig::clear_upload_stat() {
  upload_stat_ = false;
  clear_has_upload_stat();
}
bool HeartbeatConfig::upload_stat() const {
  // @@protoc_insertion_point(field_get:mcs_proto.HeartbeatConfig.upload_stat)
  return upload_stat_;
}
void HeartbeatConfig::set_upload_stat(bool value) {
  set_has_upload_stat();
  upload_stat_ = value;
  // @@protoc_insertion_point(field_set:mcs_proto.HeartbeatConfig.upload_stat)
}

// optional string ip = 2;
bool HeartbeatConfig::has_ip() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void HeartbeatConfig::set_has_ip() {
  _has_bits_[0] |= 0x00000001u;
}
void HeartbeatConfig::clear_has_ip() {
  _has_bits_[0] &= ~0x00000001u;
}
void HeartbeatConfig::clear_ip() {
  ip_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_ip();
}
const ::std::string& HeartbeatConfig::ip() const {
  // @@protoc_insertion_point(field_get:mcs_proto.HeartbeatConfig.ip)
  return ip_.GetNoArena();
}
void HeartbeatConfig::set_ip(const ::std::string& value) {
  set_has_ip();
  ip_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:mcs_proto.HeartbeatConfig.ip)
}
#if LANG_CXX11
void HeartbeatConfig::set_ip(::std::string&& value) {
  set_has_ip();
  ip_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:mcs_proto.HeartbeatConfig.ip)
}
#endif
void HeartbeatConfig::set_ip(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_ip();
  ip_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:mcs_proto.HeartbeatConfig.ip)
}
void HeartbeatConfig::set_ip(const char* value, size_t size) {
  set_has_ip();
  ip_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:mcs_proto.HeartbeatConfig.ip)
}
::std::string* HeartbeatConfig::mutable_ip() {
  set_has_ip();
  // @@protoc_insertion_point(field_mutable:mcs_proto.HeartbeatConfig.ip)
  return ip_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* HeartbeatConfig::release_ip() {
  // @@protoc_insertion_point(field_release:mcs_proto.HeartbeatConfig.ip)
  clear_has_ip();
  return ip_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void HeartbeatConfig::set_allocated_ip(::std::string* ip) {
  if (ip != NULL) {
    set_has_ip();
  } else {
    clear_has_ip();
  }
  ip_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ip);
  // @@protoc_insertion_point(field_set_allocated:mcs_proto.HeartbeatConfig.ip)
}

// optional int32 interval_ms = 3;
bool HeartbeatConfig::has_interval_ms() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
void HeartbeatConfig::set_has_interval_ms() {
  _has_bits_[0] |= 0x00000004u;
}
void HeartbeatConfig::clear_has_interval_ms() {
  _has_bits_[0] &= ~0x00000004u;
}
void HeartbeatConfig::clear_interval_ms() {
  interval_ms_ = 0;
  clear_has_interval_ms();
}
::google::protobuf::int32 HeartbeatConfig::interval_ms() const {
  // @@protoc_insertion_point(field_get:mcs_proto.HeartbeatConfig.interval_ms)
  return interval_ms_;
}
void HeartbeatConfig::set_interval_ms(::google::protobuf::int32 value) {
  set_has_interval_ms();
  interval_ms_ = value;
  // @@protoc_insertion_point(field_set:mcs_proto.HeartbeatConfig.interval_ms)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int ClientEvent::kTypeFieldNumber;
const int ClientEvent::kNumberDiscardedEventsFieldNumber;
const int ClientEvent::kNetworkTypeFieldNumber;
const int ClientEvent::kTimeConnectionStartedMsFieldNumber;
const int ClientEvent::kTimeConnectionEndedMsFieldNumber;
const int ClientEvent::kErrorCodeFieldNumber;
const int ClientEvent::kTimeConnectionEstablishedMsFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

ClientEvent::ClientEvent()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_mcs_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:mcs_proto.ClientEvent)
}
ClientEvent::ClientEvent(const ClientEvent& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&type_, &from.type_,
    static_cast<size_t>(reinterpret_cast<char*>(&time_connection_established_ms_) -
    reinterpret_cast<char*>(&type_)) + sizeof(time_connection_established_ms_));
  // @@protoc_insertion_point(copy_constructor:mcs_proto.ClientEvent)
}

void ClientEvent::SharedCtor() {
  _cached_size_ = 0;
  ::memset(&type_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&time_connection_established_ms_) -
      reinterpret_cast<char*>(&type_)) + sizeof(time_connection_established_ms_));
}

ClientEvent::~ClientEvent() {
  // @@protoc_insertion_point(destructor:mcs_proto.ClientEvent)
  SharedDtor();
}

void ClientEvent::SharedDtor() {
}

void ClientEvent::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ClientEvent& ClientEvent::default_instance() {
  protobuf_mcs_2eproto::InitDefaults();
  return *internal_default_instance();
}

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

void ClientEvent::Clear() {
// @@protoc_insertion_point(message_clear_start:mcs_proto.ClientEvent)
  if (_has_bits_[0 / 32] & 127u) {
    ::memset(&type_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&time_connection_established_ms_) -
        reinterpret_cast<char*>(&type_)) + sizeof(time_connection_established_ms_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool ClientEvent::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:mcs_proto.ClientEvent)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(16383u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .mcs_proto.ClientEvent.Type type = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::mcs_proto::ClientEvent_Type_IsValid(value)) {
            set_type(static_cast< ::mcs_proto::ClientEvent_Type >(value));
          } else {
            unknown_fields_stream.WriteVarint32(8u);
            unknown_fields_stream.WriteVarint32(
                static_cast< ::google::protobuf::uint32>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 number_discarded_events = 100;
      case 100: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(32u)) {
          set_has_number_discarded_events();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &number_discarded_events_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 network_type = 200;
      case 200: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(64u)) {
          set_has_network_type();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &network_type_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint64 time_connection_started_ms = 202;
      case 202: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(80u)) {
          set_has_time_connection_started_ms();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
                 input, &time_connection_started_ms_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint64 time_connection_ended_ms = 203;
      case 203: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(88u)) {
          set_has_time_connection_ended_ms();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
                 input, &time_connection_ended_ms_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 error_code = 204;
      case 204: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(96u)) {
          set_has_error_code();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &error_code_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint64 time_connection_established_ms = 300;
      case 300: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(96u)) {
          set_has_time_connection_established_ms();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
                 input, &time_connection_established_ms_)));
        } else {
          goto handle_unusual;
        }
        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::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:mcs_proto.ClientEvent)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:mcs_proto.ClientEvent)
  return false;
#undef DO_
}

void ClientEvent::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:mcs_proto.ClientEvent)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .mcs_proto.ClientEvent.Type type = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->type(), output);
  }

  // optional uint32 number_discarded_events = 100;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(100, this->number_discarded_events(), output);
  }

  // optional int32 network_type = 200;
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(200, this->network_type(), output);
  }

  // optional uint64 time_connection_started_ms = 202;
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt64(202, this->time_connection_started_ms(), output);
  }

  // optional uint64 time_connection_ended_ms = 203;
  if (cached_has_bits & 0x00000020u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt64(203, this->time_connection_ended_ms(), output);
  }

  // optional int32 error_code = 204;
  if (cached_has_bits & 0x00000010u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(204, this->error_code(), output);
  }

  // optional uint64 time_connection_established_ms = 300;
  if (cached_has_bits & 0x00000040u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt64(300, this->time_connection_established_ms(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:mcs_proto.ClientEvent)
}

size_t ClientEvent::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:mcs_proto.ClientEvent)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  if (_has_bits_[0 / 32] & 127u) {
    // optional .mcs_proto.ClientEvent.Type type = 1;
    if (has_type()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->type());
    }

    // optional uint32 number_discarded_events = 100;
    if (has_number_discarded_events()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->number_discarded_events());
    }

    // optional uint64 time_connection_started_ms = 202;
    if (has_time_connection_started_ms()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::UInt64Size(
          this->time_connection_started_ms());
    }

    // optional int32 network_type = 200;
    if (has_network_type()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->network_type());
    }

    // optional int32 error_code = 204;
    if (has_error_code()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->error_code());
    }

    // optional uint64 time_connection_ended_ms = 203;
    if (has_time_connection_ended_ms()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::UInt64Size(
          this->time_connection_ended_ms());
    }

    // optional uint64 time_connection_established_ms = 300;
    if (has_time_connection_established_ms()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::UInt64Size(
          this->time_connection_established_ms());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

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

void ClientEvent::MergeFrom(const ClientEvent& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:mcs_proto.ClientEvent)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 127u) {
    if (cached_has_bits & 0x00000001u) {
      type_ = from.type_;
    }
    if (cached_has_bits & 0x00000002u) {
      number_discarded_events_ = from.number_discarded_events_;
    }
    if (cached_has_bits & 0x00000004u) {
      time_connection_started_ms_ = from.time_connection_started_ms_;
    }
    if (cached_has_bits & 0x00000008u) {
      network_type_ = from.network_type_;
    }
    if (cached_has_bits & 0x00000010u) {
      error_code_ = from.error_code_;
    }
    if (cached_has_bits & 0x00000020u) {
      time_connection_ended_ms_ = from.time_connection_ended_ms_;
    }
    if (cached_has_bits & 0x00000040u) {
      time_connection_established_ms_ = from.time_connection_established_ms_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void ClientEvent::CopyFrom(const ClientEvent& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:mcs_proto.ClientEvent)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ClientEvent::IsInitialized() const {
  return true;
}

void ClientEvent::Swap(ClientEvent* other) {
  if (other == this) return;
  InternalSwap(other);
}
void ClientEvent::InternalSwap(ClientEvent* other) {
  std::swap(type_, other->type_);
  std::swap(number_discarded_events_, other->number_discarded_events_);
  std::swap(time_connection_started_ms_, other->time_connection_started_ms_);
  std::swap(network_type_, other->network_type_);
  std::swap(error_code_, other->error_code_);
  std::swap(time_connection_ended_ms_, other->time_connection_ended_ms_);
  std::swap(time_connection_established_ms_, other->time_connection_established_ms_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string ClientEvent::GetTypeName() const {
  return "mcs_proto.ClientEvent";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// ClientEvent

// optional .mcs_proto.ClientEvent.Type type = 1;
bool ClientEvent::has_type() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void ClientEvent::set_has_type() {
  _has_bits_[0] |= 0x00000001u;
}
void ClientEvent::clear_has_type() {
  _has_bits_[0] &= ~0x00000001u;
}
void ClientEvent::clear_type() {
  type_ = 0;
  clear_has_type();
}
::mcs_proto::ClientEvent_Type ClientEvent::type() const {
  // @@protoc_insertion_point(field_get:mcs_proto.ClientEvent.type)
  return static_cast< ::mcs_proto::ClientEvent_Type >(type_);
}
void ClientEvent::set_type(::mcs_proto::ClientEvent_Type value) {
  assert(::mcs_proto::ClientEvent_Type_IsValid(value));
  set_has_type();
  type_ = value;
  // @@protoc_insertion_point(field_set:mcs_proto.ClientEvent.type)
}

// optional uint32 number_discarded_events = 100;
bool ClientEvent::has_number_discarded_events() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void ClientEvent::set_has_number_discarded_events() {
  _has_bits_[0] |= 0x00000002u;
}
void ClientEvent::clear_has_number_discarded_events() {
  _has_bits_[0] &= ~0x00000002u;
}
void ClientEvent::clear_number_discarded_events() {
  number_discarded_events_ = 0u;
  clear_has_number_discarded_events();
}
::google::protobuf::uint32 ClientEvent::number_discarded_events() const {
  // @@protoc_insertion_point(field_get:mcs_proto.ClientEvent.number_discarded_events)
  return number_discarded_events_;
}
void ClientEvent::set_number_discarded_events(::google::protobuf::uint32 value) {
  set_has_number_discarded_events();
  number_discarded_events_ = value;
  // @@protoc_insertion_point(field_set:mcs_proto.ClientEvent.number_discarded_events)
}

// optional int32 network_type = 200;
bool ClientEvent::has_network_type() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
void ClientEvent::set_has_network_type() {
  _has_bits_[0] |= 0x00000008u;
}
void ClientEvent::clear_has_network_type() {
  _has_bits_[0] &= ~0x00000008u;
}
void ClientEvent::clear_network_type() {
  network_type_ = 0;
  clear_has_network_type();
}
::google::protobuf::int32 ClientEvent::network_type() const {
  // @@protoc_insertion_point(field_get:mcs_proto.ClientEvent.network_type)
  return network_type_;
}
void ClientEvent::set_network_type(::google::protobuf::int32 value) {
  set_has_network_type();
  network_type_ = value;
  // @@protoc_insertion_point(field_set:mcs_proto.ClientEvent.network_type)
}

// optional uint64 time_connection_started_ms = 202;
bool ClientEvent::has_time_connection_started_ms() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
void ClientEvent::set_has_time_connection_started_ms() {
  _has_bits_[0] |= 0x00000004u;
}
void ClientEvent::clear_has_time_connection_started_ms() {
  _has_bits_[0] &= ~0x00000004u;
}
void ClientEvent::clear_time_connection_started_ms() {
  time_connection_started_ms_ = GOOGLE_ULONGLONG(0);
  clear_has_time_connection_started_ms();
}
::google::protobuf::uint64 ClientEvent::time_connection_started_ms() const {
  // @@protoc_insertion_point(field_get:mcs_proto.ClientEvent.time_connection_started_ms)
  return time_connection_started_ms_;
}
void ClientEvent::set_time_connection_started_ms(::google::protobuf::uint64 value) {
  set_has_time_connection_started_ms();
  time_connection_started_ms_ = value;
  // @@protoc_insertion_point(field_set:mcs_proto.ClientEvent.time_connection_started_ms)
}

// optional uint64 time_connection_ended_ms = 203;
bool ClientEvent::has_time_connection_ended_ms() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
void ClientEvent::set_has_time_connection_ended_ms() {
  _has_bits_[0] |= 0x00000020u;
}
void ClientEvent::clear_has_time_connection_ended_ms() {
  _has_bits_[0] &= ~0x00000020u;
}
void ClientEvent::clear_time_connection_ended_ms() {
  time_connection_ended_ms_ = GOOGLE_ULONGLONG(0);
  clear_has_time_connection_ended_ms();
}
::google::protobuf::uint64 ClientEvent::time_connection_ended_ms() const {
  // @@protoc_insertion_point(field_get:mcs_proto.ClientEvent.time_connection_ended_ms)
  return time_connection_ended_ms_;
}
void ClientEvent::set_time_connection_ended_ms(::google::protobuf::uint64 value) {
  set_has_time_connection_ended_ms();
  time_connection_ended_ms_ = value;
  // @@protoc_insertion_point(field_set:mcs_proto.ClientEvent.time_connection_ended_ms)
}

// optional int32 error_code = 204;
bool ClientEvent::has_error_code() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
void ClientEvent::set_has_error_code() {
  _has_bits_[0] |= 0x00000010u;
}
void ClientEvent::clear_has_error_code() {
  _has_bits_[0] &= ~0x00000010u;
}
void ClientEvent::clear_error_code() {
  error_code_ = 0;
  clear_has_error_code();
}
::google::protobuf::int32 ClientEvent::error_code() const {
  // @@protoc_insertion_point(field_get:mcs_proto.ClientEvent.error_code)
  return error_code_;
}
void ClientEvent::set_error_code(::google::protobuf::int32 value) {
  set_has_error_code();
  error_code_ = value;
  // @@protoc_insertion_point(field_set:mcs_proto.ClientEvent.error_code)
}

// optional uint64 time_connection_established_ms = 300;
bool ClientEvent::has_time_connection_established_ms() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
void ClientEvent::set_has_time_connection_established_ms() {
  _has_bits_[0] |= 0x00000040u;
}
void ClientEvent::clear_has_time_connection_established_ms() {
  _has_bits_[0] &= ~0x00000040u;
}
void ClientEvent::clear_time_connection_established_ms() {
  time_connection_established_ms_ = GOOGLE_ULONGLONG(0);
  clear_has_time_connection_established_ms();
}
::google::protobuf::uint64 ClientEvent::time_connection_established_ms() const {
  // @@protoc_insertion_point(field_get:mcs_proto.ClientEvent.time_connection_established_ms)
  return time_connection_established_ms_;
}
void ClientEvent::set_time_connection_established_ms(::google::protobuf::uint64 value) {
  set_has_time_connection_established_ms();
  time_connection_established_ms_ = value;
  // @@protoc_insertion_point(field_set:mcs_proto.ClientEvent.time_connection_established_ms)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int LoginRequest::kIdFieldNumber;
const int LoginRequest::kDomainFieldNumber;
const int LoginRequest::kUserFieldNumber;
const int LoginRequest::kResourceFieldNumber;
const int LoginRequest::kAuthTokenFieldNumber;
const int LoginRequest::kDeviceIdFieldNumber;
const int LoginRequest::kLastRmqIdFieldNumber;
const int LoginRequest::kSettingFieldNumber;
const int LoginRequest::kReceivedPersistentIdFieldNumber;
const int LoginRequest::kAdaptiveHeartbeatFieldNumber;
const int LoginRequest::kHeartbeatStatFieldNumber;
const int LoginRequest::kUseRmq2FieldNumber;
const int LoginRequest::kAccountIdFieldNumber;
const int LoginRequest::kAuthServiceFieldNumber;
const int LoginRequest::kNetworkTypeFieldNumber;
const int LoginRequest::kStatusFieldNumber;
const int LoginRequest::kClientEventFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

LoginRequest::LoginRequest()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_mcs_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:mcs_proto.LoginRequest)
}
LoginRequest::LoginRequest(const LoginRequest& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0),
      setting_(from.setting_),
      received_persistent_id_(from.received_persistent_id_),
      client_event_(from.client_event_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_id()) {
    id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.id_);
  }
  domain_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_domain()) {
    domain_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.domain_);
  }
  user_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_user()) {
    user_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.user_);
  }
  resource_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_resource()) {
    resource_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.resource_);
  }
  auth_token_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_auth_token()) {
    auth_token_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.auth_token_);
  }
  device_id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_device_id()) {
    device_id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.device_id_);
  }
  if (from.has_heartbeat_stat()) {
    heartbeat_stat_ = new ::mcs_proto::HeartbeatStat(*from.heartbeat_stat_);
  } else {
    heartbeat_stat_ = NULL;
  }
  ::memcpy(&last_rmq_id_, &from.last_rmq_id_,
    static_cast<size_t>(reinterpret_cast<char*>(&auth_service_) -
    reinterpret_cast<char*>(&last_rmq_id_)) + sizeof(auth_service_));
  // @@protoc_insertion_point(copy_constructor:mcs_proto.LoginRequest)
}

void LoginRequest::SharedCtor() {
  _cached_size_ = 0;
  id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  domain_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  user_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  resource_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  auth_token_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  device_id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(&heartbeat_stat_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&status_) -
      reinterpret_cast<char*>(&heartbeat_stat_)) + sizeof(status_));
  auth_service_ = 2;
}

LoginRequest::~LoginRequest() {
  // @@protoc_insertion_point(destructor:mcs_proto.LoginRequest)
  SharedDtor();
}

void LoginRequest::SharedDtor() {
  id_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  domain_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  user_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  resource_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  auth_token_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  device_id_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (this != internal_default_instance()) {
    delete heartbeat_stat_;
  }
}

void LoginRequest::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const LoginRequest& LoginRequest::default_instance() {
  protobuf_mcs_2eproto::InitDefaults();
  return *internal_default_instance();
}

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

void LoginRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:mcs_proto.LoginRequest)
  setting_.Clear();
  received_persistent_id_.Clear();
  client_event_.Clear();
  if (_has_bits_[0 / 32] & 127u) {
    if (has_id()) {
      GOOGLE_DCHECK(!id_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*id_.UnsafeRawStringPointer())->clear();
    }
    if (has_domain()) {
      GOOGLE_DCHECK(!domain_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*domain_.UnsafeRawStringPointer())->clear();
    }
    if (has_user()) {
      GOOGLE_DCHECK(!user_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*user_.UnsafeRawStringPointer())->clear();
    }
    if (has_resource()) {
      GOOGLE_DCHECK(!resource_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*resource_.UnsafeRawStringPointer())->clear();
    }
    if (has_auth_token()) {
      GOOGLE_DCHECK(!auth_token_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*auth_token_.UnsafeRawStringPointer())->clear();
    }
    if (has_device_id()) {
      GOOGLE_DCHECK(!device_id_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*device_id_.UnsafeRawStringPointer())->clear();
    }
    if (has_heartbeat_stat()) {
      GOOGLE_DCHECK(heartbeat_stat_ != NULL);
      heartbeat_stat_->::mcs_proto::HeartbeatStat::Clear();
    }
  }
  last_rmq_id_ = GOOGLE_LONGLONG(0);
  if (_has_bits_[8 / 32] & 16128u) {
    ::memset(&adaptive_heartbeat_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&status_) -
        reinterpret_cast<char*>(&adaptive_heartbeat_)) + sizeof(status_));
    auth_service_ = 2;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool LoginRequest::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:mcs_proto.LoginRequest)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(16383u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required string id = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_id()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // required string domain = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(18u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_domain()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // required string user = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(26u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_user()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // required string resource = 4;
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(34u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_resource()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // required string auth_token = 5;
      case 5: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(42u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_auth_token()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional string device_id = 6;
      case 6: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(50u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_device_id()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int64 last_rmq_id = 7;
      case 7: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(56u)) {
          set_has_last_rmq_id();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &last_rmq_id_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated .mcs_proto.Setting setting = 8;
      case 8: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(66u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_setting()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated string received_persistent_id = 10;
      case 10: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(82u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->add_received_persistent_id()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool adaptive_heartbeat = 12;
      case 12: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(96u)) {
          set_has_adaptive_heartbeat();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &adaptive_heartbeat_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .mcs_proto.HeartbeatStat heartbeat_stat = 13;
      case 13: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(106u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_heartbeat_stat()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool use_rmq2 = 14;
      case 14: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(112u)) {
          set_has_use_rmq2();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &use_rmq2_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int64 account_id = 15;
      case 15: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(120u)) {
          set_has_account_id();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &account_id_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .mcs_proto.LoginRequest.AuthService auth_service = 16;
      case 16: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(128u)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::mcs_proto::LoginRequest_AuthService_IsValid(value)) {
            set_auth_service(static_cast< ::mcs_proto::LoginRequest_AuthService >(value));
          } else {
            unknown_fields_stream.WriteVarint32(128u);
            unknown_fields_stream.WriteVarint32(
                static_cast< ::google::protobuf::uint32>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 network_type = 17;
      case 17: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(136u)) {
          set_has_network_type();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &network_type_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int64 status = 18;
      case 18: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(144u)) {
          set_has_status();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &status_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated .mcs_proto.ClientEvent client_event = 22;
      case 22: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(178u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_client_event()));
        } else {
          goto handle_unusual;
        }
        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::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:mcs_proto.LoginRequest)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:mcs_proto.LoginRequest)
  return false;
#undef DO_
}

void LoginRequest::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:mcs_proto.LoginRequest)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required string id = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->id(), output);
  }

  // required string domain = 2;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      2, this->domain(), output);
  }

  // required string user = 3;
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      3, this->user(), output);
  }

  // required string resource = 4;
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      4, this->resource(), output);
  }

  // required string auth_token = 5;
  if (cached_has_bits & 0x00000010u) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      5, this->auth_token(), output);
  }

  // optional string device_id = 6;
  if (cached_has_bits & 0x00000020u) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      6, this->device_id(), output);
  }

  // optional int64 last_rmq_id = 7;
  if (cached_has_bits & 0x00000080u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(7, this->last_rmq_id(), output);
  }

  // repeated .mcs_proto.Setting setting = 8;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->setting_size()); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      8, this->setting(static_cast<int>(i)), output);
  }

  // repeated string received_persistent_id = 10;
  for (int i = 0, n = this->received_persistent_id_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteString(
      10, this->received_persistent_id(i), output);
  }

  // optional bool adaptive_heartbeat = 12;
  if (cached_has_bits & 0x00000100u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(12, this->adaptive_heartbeat(), output);
  }

  // optional .mcs_proto.HeartbeatStat heartbeat_stat = 13;
  if (cached_has_bits & 0x00000040u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      13, *this->heartbeat_stat_, output);
  }

  // optional bool use_rmq2 = 14;
  if (cached_has_bits & 0x00000200u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(14, this->use_rmq2(), output);
  }

  // optional int64 account_id = 15;
  if (cached_has_bits & 0x00000800u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(15, this->account_id(), output);
  }

  // optional .mcs_proto.LoginRequest.AuthService auth_service = 16;
  if (cached_has_bits & 0x00002000u) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      16, this->auth_service(), output);
  }

  // optional int32 network_type = 17;
  if (cached_has_bits & 0x00000400u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(17, this->network_type(), output);
  }

  // optional int64 status = 18;
  if (cached_has_bits & 0x00001000u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(18, this->status(), output);
  }

  // repeated .mcs_proto.ClientEvent client_event = 22;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->client_event_size()); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      22, this->client_event(static_cast<int>(i)), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:mcs_proto.LoginRequest)
}

size_t LoginRequest::RequiredFieldsByteSizeFallback() const {
// @@protoc_insertion_point(required_fields_byte_size_fallback_start:mcs_proto.LoginRequest)
  size_t total_size = 0;

  if (has_id()) {
    // required string id = 1;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::StringSize(
        this->id());
  }

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

  if (has_user()) {
    // required string user = 3;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::StringSize(
        this->user());
  }

  if (has_resource()) {
    // required string resource = 4;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::StringSize(
        this->resource());
  }

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

  return total_size;
}
size_t LoginRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:mcs_proto.LoginRequest)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  if (((_has_bits_[0] & 0x0000001f) ^ 0x0000001f) == 0) {  // All required fields are present.
    // required string id = 1;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::StringSize(
        this->id());

    // required string domain = 2;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::StringSize(
        this->domain());

    // required string user = 3;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::StringSize(
        this->user());

    // required string resource = 4;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::StringSize(
        this->resource());

    // required string auth_token = 5;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::StringSize(
        this->auth_token());

  } else {
    total_size += RequiredFieldsByteSizeFallback();
  }
  // repeated .mcs_proto.Setting setting = 8;
  {
    unsigned int count = static_cast<unsigned int>(this->setting_size());
    total_size += 1UL * count;
    for (unsigned int i = 0; i < count; i++) {
      total_size +=
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->setting(static_cast<int>(i)));
    }
  }

  // repeated string received_persistent_id = 10;
  total_size += 1 *
      ::google::protobuf::internal::FromIntSize(this->received_persistent_id_size());
  for (int i = 0, n = this->received_persistent_id_size(); i < n; i++) {
    total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
      this->received_persistent_id(i));
  }

  // repeated .mcs_proto.ClientEvent client_event = 22;
  {
    unsigned int count = static_cast<unsigned int>(this->client_event_size());
    total_size += 2UL * count;
    for (unsigned int i = 0; i < count; i++) {
      total_size +=
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->client_event(static_cast<int>(i)));
    }
  }

  if (_has_bits_[0 / 32] & 224u) {
    // optional string device_id = 6;
    if (has_device_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->device_id());
    }

    // optional .mcs_proto.HeartbeatStat heartbeat_stat = 13;
    if (has_heartbeat_stat()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *this->heartbeat_stat_);
    }

    // optional int64 last_rmq_id = 7;
    if (has_last_rmq_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->last_rmq_id());
    }

  }
  if (_has_bits_[8 / 32] & 16128u) {
    // optional bool adaptive_heartbeat = 12;
    if (has_adaptive_heartbeat()) {
      total_size += 1 + 1;
    }

    // optional bool use_rmq2 = 14;
    if (has_use_rmq2()) {
      total_size += 1 + 1;
    }

    // optional int32 network_type = 17;
    if (has_network_type()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->network_type());
    }

    // optional int64 account_id = 15;
    if (has_account_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->account_id());
    }

    // optional int64 status = 18;
    if (has_status()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->status());
    }

    // optional .mcs_proto.LoginRequest.AuthService auth_service = 16;
    if (has_auth_service()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->auth_service());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

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

void LoginRequest::MergeFrom(const LoginRequest& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:mcs_proto.LoginRequest)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  setting_.MergeFrom(from.setting_);
  received_persistent_id_.MergeFrom(from.received_persistent_id_);
  client_event_.MergeFrom(from.client_event_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 255u) {
    if (cached_has_bits & 0x00000001u) {
      set_has_id();
      id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.id_);
    }
    if (cached_has_bits & 0x00000002u) {
      set_has_domain();
      domain_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.domain_);
    }
    if (cached_has_bits & 0x00000004u) {
      set_has_user();
      user_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.user_);
    }
    if (cached_has_bits & 0x00000008u) {
      set_has_resource();
      resource_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.resource_);
    }
    if (cached_has_bits & 0x00000010u) {
      set_has_auth_token();
      auth_token_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.auth_token_);
    }
    if (cached_has_bits & 0x00000020u) {
      set_has_device_id();
      device_id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.device_id_);
    }
    if (cached_has_bits & 0x00000040u) {
      mutable_heartbeat_stat()->::mcs_proto::HeartbeatStat::MergeFrom(from.heartbeat_stat());
    }
    if (cached_has_bits & 0x00000080u) {
      last_rmq_id_ = from.last_rmq_id_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  if (cached_has_bits & 16128u) {
    if (cached_has_bits & 0x00000100u) {
      adaptive_heartbeat_ = from.adaptive_heartbeat_;
    }
    if (cached_has_bits & 0x00000200u) {
      use_rmq2_ = from.use_rmq2_;
    }
    if (cached_has_bits & 0x00000400u) {
      network_type_ = from.network_type_;
    }
    if (cached_has_bits & 0x00000800u) {
      account_id_ = from.account_id_;
    }
    if (cached_has_bits & 0x00001000u) {
      status_ = from.status_;
    }
    if (cached_has_bits & 0x00002000u) {
      auth_service_ = from.auth_service_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void LoginRequest::CopyFrom(const LoginRequest& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:mcs_proto.LoginRequest)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool LoginRequest::IsInitialized() const {
  if ((_has_bits_[0] & 0x0000001f) != 0x0000001f) return false;
  if (!::google::protobuf::internal::AllAreInitialized(this->setting())) return false;
  if (has_heartbeat_stat()) {
    if (!this->heartbeat_stat_->IsInitialized()) return false;
  }
  return true;
}

void LoginRequest::Swap(LoginRequest* other) {
  if (other == this) return;
  InternalSwap(other);
}
void LoginRequest::InternalSwap(LoginRequest* other) {
  setting_.InternalSwap(&other->setting_);
  received_persistent_id_.InternalSwap(&other->received_persistent_id_);
  client_event_.InternalSwap(&other->client_event_);
  id_.Swap(&other->id_);
  domain_.Swap(&other->domain_);
  user_.Swap(&other->user_);
  resource_.Swap(&other->resource_);
  auth_token_.Swap(&other->auth_token_);
  device_id_.Swap(&other->device_id_);
  std::swap(heartbeat_stat_, other->heartbeat_stat_);
  std::swap(last_rmq_id_, other->last_rmq_id_);
  std::swap(adaptive_heartbeat_, other->adaptive_heartbeat_);
  std::swap(use_rmq2_, other->use_rmq2_);
  std::swap(network_type_, other->network_type_);
  std::swap(account_id_, other->account_id_);
  std::swap(status_, other->status_);
  std::swap(auth_service_, other->auth_service_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string LoginRequest::GetTypeName() const {
  return "mcs_proto.LoginRequest";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// LoginRequest

// required string id = 1;
bool LoginRequest::has_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void LoginRequest::set_has_id() {
  _has_bits_[0] |= 0x00000001u;
}
void LoginRequest::clear_has_id() {
  _has_bits_[0] &= ~0x00000001u;
}
void LoginRequest::clear_id() {
  id_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_id();
}
const ::std::string& LoginRequest::id() const {
  // @@protoc_insertion_point(field_get:mcs_proto.LoginRequest.id)
  return id_.GetNoArena();
}
void LoginRequest::set_id(const ::std::string& value) {
  set_has_id();
  id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:mcs_proto.LoginRequest.id)
}
#if LANG_CXX11
void LoginRequest::set_id(::std::string&& value) {
  set_has_id();
  id_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:mcs_proto.LoginRequest.id)
}
#endif
void LoginRequest::set_id(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_id();
  id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:mcs_proto.LoginRequest.id)
}
void LoginRequest::set_id(const char* value, size_t size) {
  set_has_id();
  id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:mcs_proto.LoginRequest.id)
}
::std::string* LoginRequest::mutable_id() {
  set_has_id();
  // @@protoc_insertion_point(field_mutable:mcs_proto.LoginRequest.id)
  return id_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* LoginRequest::release_id() {
  // @@protoc_insertion_point(field_release:mcs_proto.LoginRequest.id)
  clear_has_id();
  return id_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void LoginRequest::set_allocated_id(::std::string* id) {
  if (id != NULL) {
    set_has_id();
  } else {
    clear_has_id();
  }
  id_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), id);
  // @@protoc_insertion_point(field_set_allocated:mcs_proto.LoginRequest.id)
}

// required string domain = 2;
bool LoginRequest::has_domain() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void LoginRequest::set_has_domain() {
  _has_bits_[0] |= 0x00000002u;
}
void LoginRequest::clear_has_domain() {
  _has_bits_[0] &= ~0x00000002u;
}
void LoginRequest::clear_domain() {
  domain_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_domain();
}
const ::std::string& LoginRequest::domain() const {
  // @@protoc_insertion_point(field_get:mcs_proto.LoginRequest.domain)
  return domain_.GetNoArena();
}
void LoginRequest::set_domain(const ::std::string& value) {
  set_has_domain();
  domain_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:mcs_proto.LoginRequest.domain)
}
#if LANG_CXX11
void LoginRequest::set_domain(::std::string&& value) {
  set_has_domain();
  domain_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:mcs_proto.LoginRequest.domain)
}
#endif
void LoginRequest::set_domain(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_domain();
  domain_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:mcs_proto.LoginRequest.domain)
}
void LoginRequest::set_domain(const char* value, size_t size) {
  set_has_domain();
  domain_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:mcs_proto.LoginRequest.domain)
}
::std::string* LoginRequest::mutable_domain() {
  set_has_domain();
  // @@protoc_insertion_point(field_mutable:mcs_proto.LoginRequest.domain)
  return domain_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* LoginRequest::release_domain() {
  // @@protoc_insertion_point(field_release:mcs_proto.LoginRequest.domain)
  clear_has_domain();
  return domain_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void LoginRequest::set_allocated_domain(::std::string* domain) {
  if (domain != NULL) {
    set_has_domain();
  } else {
    clear_has_domain();
  }
  domain_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), domain);
  // @@protoc_insertion_point(field_set_allocated:mcs_proto.LoginRequest.domain)
}

// required string user = 3;
bool LoginRequest::has_user() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
void LoginRequest::set_has_user() {
  _has_bits_[0] |= 0x00000004u;
}
void LoginRequest::clear_has_user() {
  _has_bits_[0] &= ~0x00000004u;
}
void LoginRequest::clear_user() {
  user_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_user();
}
const ::std::string& LoginRequest::user() const {
  // @@protoc_insertion_point(field_get:mcs_proto.LoginRequest.user)
  return user_.GetNoArena();
}
void LoginRequest::set_user(const ::std::string& value) {
  set_has_user();
  user_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:mcs_proto.LoginRequest.user)
}
#if LANG_CXX11
void LoginRequest::set_user(::std::string&& value) {
  set_has_user();
  user_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:mcs_proto.LoginRequest.user)
}
#endif
void LoginRequest::set_user(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_user();
  user_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:mcs_proto.LoginRequest.user)
}
void LoginRequest::set_user(const char* value, size_t size) {
  set_has_user();
  user_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:mcs_proto.LoginRequest.user)
}
::std::string* LoginRequest::mutable_user() {
  set_has_user();
  // @@protoc_insertion_point(field_mutable:mcs_proto.LoginRequest.user)
  return user_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* LoginRequest::release_user() {
  // @@protoc_insertion_point(field_release:mcs_proto.LoginRequest.user)
  clear_has_user();
  return user_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void LoginRequest::set_allocated_user(::std::string* user) {
  if (user != NULL) {
    set_has_user();
  } else {
    clear_has_user();
  }
  user_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), user);
  // @@protoc_insertion_point(field_set_allocated:mcs_proto.LoginRequest.user)
}

// required string resource = 4;
bool LoginRequest::has_resource() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
void LoginRequest::set_has_resource() {
  _has_bits_[0] |= 0x00000008u;
}
void LoginRequest::clear_has_resource() {
  _has_bits_[0] &= ~0x00000008u;
}
void LoginRequest::clear_resource() {
  resource_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_resource();
}
const ::std::string& LoginRequest::resource() const {
  // @@protoc_insertion_point(field_get:mcs_proto.LoginRequest.resource)
  return resource_.GetNoArena();
}
void LoginRequest::set_resource(const ::std::string& value) {
  set_has_resource();
  resource_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:mcs_proto.LoginRequest.resource)
}
#if LANG_CXX11
void LoginRequest::set_resource(::std::string&& value) {
  set_has_resource();
  resource_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:mcs_proto.LoginRequest.resource)
}
#endif
void LoginRequest::set_resource(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_resource();
  resource_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:mcs_proto.LoginRequest.resource)
}
void LoginRequest::set_resource(const char* value, size_t size) {
  set_has_resource();
  resource_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:mcs_proto.LoginRequest.resource)
}
::std::string* LoginRequest::mutable_resource() {
  set_has_resource();
  // @@protoc_insertion_point(field_mutable:mcs_proto.LoginRequest.resource)
  return resource_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* LoginRequest::release_resource() {
  // @@protoc_insertion_point(field_release:mcs_proto.LoginRequest.resource)
  clear_has_resource();
  return resource_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void LoginRequest::set_allocated_resource(::std::string* resource) {
  if (resource != NULL) {
    set_has_resource();
  } else {
    clear_has_resource();
  }
  resource_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), resource);
  // @@protoc_insertion_point(field_set_allocated:mcs_proto.LoginRequest.resource)
}

// required string auth_token = 5;
bool LoginRequest::has_auth_token() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
void LoginRequest::set_has_auth_token() {
  _has_bits_[0] |= 0x00000010u;
}
void LoginRequest::clear_has_auth_token() {
  _has_bits_[0] &= ~0x00000010u;
}
void LoginRequest::clear_auth_token() {
  auth_token_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_auth_token();
}
const ::std::string& LoginRequest::auth_token() const {
  // @@protoc_insertion_point(field_get:mcs_proto.LoginRequest.auth_token)
  return auth_token_.GetNoArena();
}
void LoginRequest::set_auth_token(const ::std::string& value) {
  set_has_auth_token();
  auth_token_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:mcs_proto.LoginRequest.auth_token)
}
#if LANG_CXX11
void LoginRequest::set_auth_token(::std::string&& value) {
  set_has_auth_token();
  auth_token_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:mcs_proto.LoginRequest.auth_token)
}
#endif
void LoginRequest::set_auth_token(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_auth_token();
  auth_token_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:mcs_proto.LoginRequest.auth_token)
}
void LoginRequest::set_auth_token(const char* value, size_t size) {
  set_has_auth_token();
  auth_token_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:mcs_proto.LoginRequest.auth_token)
}
::std::string* LoginRequest::mutable_auth_token() {
  set_has_auth_token();
  // @@protoc_insertion_point(field_mutable:mcs_proto.LoginRequest.auth_token)
  return auth_token_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* LoginRequest::release_auth_token() {
  // @@protoc_insertion_point(field_release:mcs_proto.LoginRequest.auth_token)
  clear_has_auth_token();
  return auth_token_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void LoginRequest::set_allocated_auth_token(::std::string* auth_token) {
  if (auth_token != NULL) {
    set_has_auth_token();
  } else {
    clear_has_auth_token();
  }
  auth_token_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), auth_token);
  // @@protoc_insertion_point(field_set_allocated:mcs_proto.LoginRequest.auth_token)
}

// optional string device_id = 6;
bool LoginRequest::has_device_id() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
void LoginRequest::set_has_device_id() {
  _has_bits_[0] |= 0x00000020u;
}
void LoginRequest::clear_has_device_id() {
  _has_bits_[0] &= ~0x00000020u;
}
void LoginRequest::clear_device_id() {
  device_id_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_device_id();
}
const ::std::string& LoginRequest::device_id() const {
  // @@protoc_insertion_point(field_get:mcs_proto.LoginRequest.device_id)
  return device_id_.GetNoArena();
}
void LoginRequest::set_device_id(const ::std::string& value) {
  set_has_device_id();
  device_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:mcs_proto.LoginRequest.device_id)
}
#if LANG_CXX11
void LoginRequest::set_device_id(::std::string&& value) {
  set_has_device_id();
  device_id_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:mcs_proto.LoginRequest.device_id)
}
#endif
void LoginRequest::set_device_id(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_device_id();
  device_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:mcs_proto.LoginRequest.device_id)
}
void LoginRequest::set_device_id(const char* value, size_t size) {
  set_has_device_id();
  device_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:mcs_proto.LoginRequest.device_id)
}
::std::string* LoginRequest::mutable_device_id() {
  set_has_device_id();
  // @@protoc_insertion_point(field_mutable:mcs_proto.LoginRequest.device_id)
  return device_id_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* LoginRequest::release_device_id() {
  // @@protoc_insertion_point(field_release:mcs_proto.LoginRequest.device_id)
  clear_has_device_id();
  return device_id_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void LoginRequest::set_allocated_device_id(::std::string* device_id) {
  if (device_id != NULL) {
    set_has_device_id();
  } else {
    clear_has_device_id();
  }
  device_id_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), device_id);
  // @@protoc_insertion_point(field_set_allocated:mcs_proto.LoginRequest.device_id)
}

// optional int64 last_rmq_id = 7;
bool LoginRequest::has_last_rmq_id() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
void LoginRequest::set_has_last_rmq_id() {
  _has_bits_[0] |= 0x00000080u;
}
void LoginRequest::clear_has_last_rmq_id() {
  _has_bits_[0] &= ~0x00000080u;
}
void LoginRequest::clear_last_rmq_id() {
  last_rmq_id_ = GOOGLE_LONGLONG(0);
  clear_has_last_rmq_id();
}
::google::protobuf::int64 LoginRequest::last_rmq_id() const {
  // @@protoc_insertion_point(field_get:mcs_proto.LoginRequest.last_rmq_id)
  return last_rmq_id_;
}
void LoginRequest::set_last_rmq_id(::google::protobuf::int64 value) {
  set_has_last_rmq_id();
  last_rmq_id_ = value;
  // @@protoc_insertion_point(field_set:mcs_proto.LoginRequest.last_rmq_id)
}

// repeated .mcs_proto.Setting setting = 8;
int LoginRequest::setting_size() const {
  return setting_.size();
}
void LoginRequest::clear_setting() {
  setting_.Clear();
}
const ::mcs_proto::Setting& LoginRequest::setting(int index) const {
  // @@protoc_insertion_point(field_get:mcs_proto.LoginRequest.setting)
  return setting_.Get(index);
}
::mcs_proto::Setting* LoginRequest::mutable_setting(int index) {
  // @@protoc_insertion_point(field_mutable:mcs_proto.LoginRequest.setting)
  return setting_.Mutable(index);
}
::mcs_proto::Setting* LoginRequest::add_setting() {
  // @@protoc_insertion_point(field_add:mcs_proto.LoginRequest.setting)
  return setting_.Add();
}
::google::protobuf::RepeatedPtrField< ::mcs_proto::Setting >*
LoginRequest::mutable_setting() {
  // @@protoc_insertion_point(field_mutable_list:mcs_proto.LoginRequest.setting)
  return &setting_;
}
const ::google::protobuf::RepeatedPtrField< ::mcs_proto::Setting >&
LoginRequest::setting() const {
  // @@protoc_insertion_point(field_list:mcs_proto.LoginRequest.setting)
  return setting_;
}

// repeated string received_persistent_id = 10;
int LoginRequest::received_persistent_id_size() const {
  return received_persistent_id_.size();
}
void LoginRequest::clear_received_persistent_id() {
  received_persistent_id_.Clear();
}
const ::std::string& LoginRequest::received_persistent_id(int index) const {
  // @@protoc_insertion_point(field_get:mcs_proto.LoginRequest.received_persistent_id)
  return received_persistent_id_.Get(index);
}
::std::string* LoginRequest::mutable_received_persistent_id(int index) {
  // @@protoc_insertion_point(field_mutable:mcs_proto.LoginRequest.received_persistent_id)
  return received_persistent_id_.Mutable(index);
}
void LoginRequest::set_received_persistent_id(int index, const ::std::string& value) {
  // @@protoc_insertion_point(field_set:mcs_proto.LoginRequest.received_persistent_id)
  received_persistent_id_.Mutable(index)->assign(value);
}
#if LANG_CXX11
void LoginRequest::set_received_persistent_id(int index, ::std::string&& value) {
  // @@protoc_insertion_point(field_set:mcs_proto.LoginRequest.received_persistent_id)
  received_persistent_id_.Mutable(index)->assign(std::move(value));
}
#endif
void LoginRequest::set_received_persistent_id(int index, const char* value) {
  GOOGLE_DCHECK(value != NULL);
  received_persistent_id_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:mcs_proto.LoginRequest.received_persistent_id)
}
void LoginRequest::set_received_persistent_id(int index, const char* value, size_t size) {
  received_persistent_id_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:mcs_proto.LoginRequest.received_persistent_id)
}
::std::string* LoginRequest::add_received_persistent_id() {
  // @@protoc_insertion_point(field_add_mutable:mcs_proto.LoginRequest.received_persistent_id)
  return received_persistent_id_.Add();
}
void LoginRequest::add_received_persistent_id(const ::std::string& value) {
  received_persistent_id_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:mcs_proto.LoginRequest.received_persistent_id)
}
#if LANG_CXX11
void LoginRequest::add_received_persistent_id(::std::string&& value) {
  received_persistent_id_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:mcs_proto.LoginRequest.received_persistent_id)
}
#endif
void LoginRequest::add_received_persistent_id(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  received_persistent_id_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:mcs_proto.LoginRequest.received_persistent_id)
}
void LoginRequest::add_received_persistent_id(const char* value, size_t size) {
  received_persistent_id_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:mcs_proto.LoginRequest.received_persistent_id)
}
const ::google::protobuf::RepeatedPtrField< ::std::string>&
LoginRequest::received_persistent_id() const {
  // @@protoc_insertion_point(field_list:mcs_proto.LoginRequest.received_persistent_id)
  return received_persistent_id_;
}
::google::protobuf::RepeatedPtrField< ::std::string>*
LoginRequest::mutable_received_persistent_id() {
  // @@protoc_insertion_point(field_mutable_list:mcs_proto.LoginRequest.received_persistent_id)
  return &received_persistent_id_;
}

// optional bool adaptive_heartbeat = 12;
bool LoginRequest::has_adaptive_heartbeat() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
void LoginRequest::set_has_adaptive_heartbeat() {
  _has_bits_[0] |= 0x00000100u;
}
void LoginRequest::clear_has_adaptive_heartbeat() {
  _has_bits_[0] &= ~0x00000100u;
}
void LoginRequest::clear_adaptive_heartbeat() {
  adaptive_heartbeat_ = false;
  clear_has_adaptive_heartbeat();
}
bool LoginRequest::adaptive_heartbeat() const {
  // @@protoc_insertion_point(field_get:mcs_proto.LoginRequest.adaptive_heartbeat)
  return adaptive_heartbeat_;
}
void LoginRequest::set_adaptive_heartbeat(bool value) {
  set_has_adaptive_heartbeat();
  adaptive_heartbeat_ = value;
  // @@protoc_insertion_point(field_set:mcs_proto.LoginRequest.adaptive_heartbeat)
}

// optional .mcs_proto.HeartbeatStat heartbeat_stat = 13;
bool LoginRequest::has_heartbeat_stat() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
void LoginRequest::set_has_heartbeat_stat() {
  _has_bits_[0] |= 0x00000040u;
}
void LoginRequest::clear_has_heartbeat_stat() {
  _has_bits_[0] &= ~0x00000040u;
}
void LoginRequest::clear_heartbeat_stat() {
  if (heartbeat_stat_ != NULL) heartbeat_stat_->::mcs_proto::HeartbeatStat::Clear();
  clear_has_heartbeat_stat();
}
const ::mcs_proto::HeartbeatStat& LoginRequest::heartbeat_stat() const {
  // @@protoc_insertion_point(field_get:mcs_proto.LoginRequest.heartbeat_stat)
  return heartbeat_stat_ != NULL ? *heartbeat_stat_
                         : *::mcs_proto::HeartbeatStat::internal_default_instance();
}
::mcs_proto::HeartbeatStat* LoginRequest::mutable_heartbeat_stat() {
  set_has_heartbeat_stat();
  if (heartbeat_stat_ == NULL) {
    heartbeat_stat_ = new ::mcs_proto::HeartbeatStat;
  }
  // @@protoc_insertion_point(field_mutable:mcs_proto.LoginRequest.heartbeat_stat)
  return heartbeat_stat_;
}
::mcs_proto::HeartbeatStat* LoginRequest::release_heartbeat_stat() {
  // @@protoc_insertion_point(field_release:mcs_proto.LoginRequest.heartbeat_stat)
  clear_has_heartbeat_stat();
  ::mcs_proto::HeartbeatStat* temp = heartbeat_stat_;
  heartbeat_stat_ = NULL;
  return temp;
}
void LoginRequest::set_allocated_heartbeat_stat(::mcs_proto::HeartbeatStat* heartbeat_stat) {
  delete heartbeat_stat_;
  heartbeat_stat_ = heartbeat_stat;
  if (heartbeat_stat) {
    set_has_heartbeat_stat();
  } else {
    clear_has_heartbeat_stat();
  }
  // @@protoc_insertion_point(field_set_allocated:mcs_proto.LoginRequest.heartbeat_stat)
}

// optional bool use_rmq2 = 14;
bool LoginRequest::has_use_rmq2() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
void LoginRequest::set_has_use_rmq2() {
  _has_bits_[0] |= 0x00000200u;
}
void LoginRequest::clear_has_use_rmq2() {
  _has_bits_[0] &= ~0x00000200u;
}
void LoginRequest::clear_use_rmq2() {
  use_rmq2_ = false;
  clear_has_use_rmq2();
}
bool LoginRequest::use_rmq2() const {
  // @@protoc_insertion_point(field_get:mcs_proto.LoginRequest.use_rmq2)
  return use_rmq2_;
}
void LoginRequest::set_use_rmq2(bool value) {
  set_has_use_rmq2();
  use_rmq2_ = value;
  // @@protoc_insertion_point(field_set:mcs_proto.LoginRequest.use_rmq2)
}

// optional int64 account_id = 15;
bool LoginRequest::has_account_id() const {
  return (_has_bits_[0] & 0x00000800u) != 0;
}
void LoginRequest::set_has_account_id() {
  _has_bits_[0] |= 0x00000800u;
}
void LoginRequest::clear_has_account_id() {
  _has_bits_[0] &= ~0x00000800u;
}
void LoginRequest::clear_account_id() {
  account_id_ = GOOGLE_LONGLONG(0);
  clear_has_account_id();
}
::google::protobuf::int64 LoginRequest::account_id() const {
  // @@protoc_insertion_point(field_get:mcs_proto.LoginRequest.account_id)
  return account_id_;
}
void LoginRequest::set_account_id(::google::protobuf::int64 value) {
  set_has_account_id();
  account_id_ = value;
  // @@protoc_insertion_point(field_set:mcs_proto.LoginRequest.account_id)
}

// optional .mcs_proto.LoginRequest.AuthService auth_service = 16;
bool LoginRequest::has_auth_service() const {
  return (_has_bits_[0] & 0x00002000u) != 0;
}
void LoginRequest::set_has_auth_service() {
  _has_bits_[0] |= 0x00002000u;
}
void LoginRequest::clear_has_auth_service() {
  _has_bits_[0] &= ~0x00002000u;
}
void LoginRequest::clear_auth_service() {
  auth_service_ = 2;
  clear_has_auth_service();
}
::mcs_proto::LoginRequest_AuthService LoginRequest::auth_service() const {
  // @@protoc_insertion_point(field_get:mcs_proto.LoginRequest.auth_service)
  return static_cast< ::mcs_proto::LoginRequest_AuthService >(auth_service_);
}
void LoginRequest::set_auth_service(::mcs_proto::LoginRequest_AuthService value) {
  assert(::mcs_proto::LoginRequest_AuthService_IsValid(value));
  set_has_auth_service();
  auth_service_ = value;
  // @@protoc_insertion_point(field_set:mcs_proto.LoginRequest.auth_service)
}

// optional int32 network_type = 17;
bool LoginRequest::has_network_type() const {
  return (_has_bits_[0] & 0x00000400u) != 0;
}
void LoginRequest::set_has_network_type() {
  _has_bits_[0] |= 0x00000400u;
}
void LoginRequest::clear_has_network_type() {
  _has_bits_[0] &= ~0x00000400u;
}
void LoginRequest::clear_network_type() {
  network_type_ = 0;
  clear_has_network_type();
}
::google::protobuf::int32 LoginRequest::network_type() const {
  // @@protoc_insertion_point(field_get:mcs_proto.LoginRequest.network_type)
  return network_type_;
}
void LoginRequest::set_network_type(::google::protobuf::int32 value) {
  set_has_network_type();
  network_type_ = value;
  // @@protoc_insertion_point(field_set:mcs_proto.LoginRequest.network_type)
}

// optional int64 status = 18;
bool LoginRequest::has_status() const {
  return (_has_bits_[0] & 0x00001000u) != 0;
}
void LoginRequest::set_has_status() {
  _has_bits_[0] |= 0x00001000u;
}
void LoginRequest::clear_has_status() {
  _has_bits_[0] &= ~0x00001000u;
}
void LoginRequest::clear_status() {
  status_ = GOOGLE_LONGLONG(0);
  clear_has_status();
}
::google::protobuf::int64 LoginRequest::status() const {
  // @@protoc_insertion_point(field_get:mcs_proto.LoginRequest.status)
  return status_;
}
void LoginRequest::set_status(::google::protobuf::int64 value) {
  set_has_status();
  status_ = value;
  // @@protoc_insertion_point(field_set:mcs_proto.LoginRequest.status)
}

// repeated .mcs_proto.ClientEvent client_event = 22;
int LoginRequest::client_event_size() const {
  return client_event_.size();
}
void LoginRequest::clear_client_event() {
  client_event_.Clear();
}
const ::mcs_proto::ClientEvent& LoginRequest::client_event(int index) const {
  // @@protoc_insertion_point(field_get:mcs_proto.LoginRequest.client_event)
  return client_event_.Get(index);
}
::mcs_proto::ClientEvent* LoginRequest::mutable_client_event(int index) {
  // @@protoc_insertion_point(field_mutable:mcs_proto.LoginRequest.client_event)
  return client_event_.Mutable(index);
}
::mcs_proto::ClientEvent* LoginRequest::add_client_event() {
  // @@protoc_insertion_point(field_add:mcs_proto.LoginRequest.client_event)
  return client_event_.Add();
}
::google::protobuf::RepeatedPtrField< ::mcs_proto::ClientEvent >*
LoginRequest::mutable_client_event() {
  // @@protoc_insertion_point(field_mutable_list:mcs_proto.LoginRequest.client_event)
  return &client_event_;
}
const ::google::protobuf::RepeatedPtrField< ::mcs_proto::ClientEvent >&
LoginRequest::client_event() const {
  // @@protoc_insertion_point(field_list:mcs_proto.LoginRequest.client_event)
  return client_event_;
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int LoginResponse::kIdFieldNumber;
const int LoginResponse::kJidFieldNumber;
const int LoginResponse::kErrorFieldNumber;
const int LoginResponse::kSettingFieldNumber;
const int LoginResponse::kStreamIdFieldNumber;
const int LoginResponse::kLastStreamIdReceivedFieldNumber;
const int LoginResponse::kHeartbeatConfigFieldNumber;
const int LoginResponse::kServerTimestampFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

LoginResponse::LoginResponse()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_mcs_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:mcs_proto.LoginResponse)
}
LoginResponse::LoginResponse(const LoginResponse& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0),
      setting_(from.setting_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_id()) {
    id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.id_);
  }
  jid_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_jid()) {
    jid_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.jid_);
  }
  if (from.has_error()) {
    error_ = new ::mcs_proto::ErrorInfo(*from.error_);
  } else {
    error_ = NULL;
  }
  if (from.has_heartbeat_config()) {
    heartbeat_config_ = new ::mcs_proto::HeartbeatConfig(*from.heartbeat_config_);
  } else {
    heartbeat_config_ = NULL;
  }
  ::memcpy(&stream_id_, &from.stream_id_,
    static_cast<size_t>(reinterpret_cast<char*>(&server_timestamp_) -
    reinterpret_cast<char*>(&stream_id_)) + sizeof(server_timestamp_));
  // @@protoc_insertion_point(copy_constructor:mcs_proto.LoginResponse)
}

void LoginResponse::SharedCtor() {
  _cached_size_ = 0;
  id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  jid_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(&error_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&server_timestamp_) -
      reinterpret_cast<char*>(&error_)) + sizeof(server_timestamp_));
}

LoginResponse::~LoginResponse() {
  // @@protoc_insertion_point(destructor:mcs_proto.LoginResponse)
  SharedDtor();
}

void LoginResponse::SharedDtor() {
  id_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  jid_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (this != internal_default_instance()) {
    delete error_;
  }
  if (this != internal_default_instance()) {
    delete heartbeat_config_;
  }
}

void LoginResponse::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const LoginResponse& LoginResponse::default_instance() {
  protobuf_mcs_2eproto::InitDefaults();
  return *internal_default_instance();
}

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

void LoginResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:mcs_proto.LoginResponse)
  setting_.Clear();
  if (_has_bits_[0 / 32] & 15u) {
    if (has_id()) {
      GOOGLE_DCHECK(!id_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*id_.UnsafeRawStringPointer())->clear();
    }
    if (has_jid()) {
      GOOGLE_DCHECK(!jid_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*jid_.UnsafeRawStringPointer())->clear();
    }
    if (has_error()) {
      GOOGLE_DCHECK(error_ != NULL);
      error_->::mcs_proto::ErrorInfo::Clear();
    }
    if (has_heartbeat_config()) {
      GOOGLE_DCHECK(heartbeat_config_ != NULL);
      heartbeat_config_->::mcs_proto::HeartbeatConfig::Clear();
    }
  }
  if (_has_bits_[0 / 32] & 112u) {
    ::memset(&stream_id_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&server_timestamp_) -
        reinterpret_cast<char*>(&stream_id_)) + sizeof(server_timestamp_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool LoginResponse::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:mcs_proto.LoginResponse)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required string id = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_id()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional string jid = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(18u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_jid()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .mcs_proto.ErrorInfo error = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(26u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_error()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated .mcs_proto.Setting setting = 4;
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(34u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_setting()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 stream_id = 5;
      case 5: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(40u)) {
          set_has_stream_id();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &stream_id_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 last_stream_id_received = 6;
      case 6: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(48u)) {
          set_has_last_stream_id_received();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &last_stream_id_received_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .mcs_proto.HeartbeatConfig heartbeat_config = 7;
      case 7: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(58u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_heartbeat_config()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int64 server_timestamp = 8;
      case 8: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(64u)) {
          set_has_server_timestamp();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &server_timestamp_)));
        } else {
          goto handle_unusual;
        }
        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::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:mcs_proto.LoginResponse)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:mcs_proto.LoginResponse)
  return false;
#undef DO_
}

void LoginResponse::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:mcs_proto.LoginResponse)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required string id = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->id(), output);
  }

  // optional string jid = 2;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      2, this->jid(), output);
  }

  // optional .mcs_proto.ErrorInfo error = 3;
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      3, *this->error_, output);
  }

  // repeated .mcs_proto.Setting setting = 4;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->setting_size()); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      4, this->setting(static_cast<int>(i)), output);
  }

  // optional int32 stream_id = 5;
  if (cached_has_bits & 0x00000010u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(5, this->stream_id(), output);
  }

  // optional int32 last_stream_id_received = 6;
  if (cached_has_bits & 0x00000020u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(6, this->last_stream_id_received(), output);
  }

  // optional .mcs_proto.HeartbeatConfig heartbeat_config = 7;
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      7, *this->heartbeat_config_, output);
  }

  // optional int64 server_timestamp = 8;
  if (cached_has_bits & 0x00000040u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(8, this->server_timestamp(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:mcs_proto.LoginResponse)
}

size_t LoginResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:mcs_proto.LoginResponse)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  // required string id = 1;
  if (has_id()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::StringSize(
        this->id());
  }
  // repeated .mcs_proto.Setting setting = 4;
  {
    unsigned int count = static_cast<unsigned int>(this->setting_size());
    total_size += 1UL * count;
    for (unsigned int i = 0; i < count; i++) {
      total_size +=
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->setting(static_cast<int>(i)));
    }
  }

  if (_has_bits_[0 / 32] & 126u) {
    // optional string jid = 2;
    if (has_jid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->jid());
    }

    // optional .mcs_proto.ErrorInfo error = 3;
    if (has_error()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *this->error_);
    }

    // optional .mcs_proto.HeartbeatConfig heartbeat_config = 7;
    if (has_heartbeat_config()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *this->heartbeat_config_);
    }

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

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

    // optional int64 server_timestamp = 8;
    if (has_server_timestamp()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->server_timestamp());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

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

void LoginResponse::MergeFrom(const LoginResponse& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:mcs_proto.LoginResponse)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  setting_.MergeFrom(from.setting_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 127u) {
    if (cached_has_bits & 0x00000001u) {
      set_has_id();
      id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.id_);
    }
    if (cached_has_bits & 0x00000002u) {
      set_has_jid();
      jid_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.jid_);
    }
    if (cached_has_bits & 0x00000004u) {
      mutable_error()->::mcs_proto::ErrorInfo::MergeFrom(from.error());
    }
    if (cached_has_bits & 0x00000008u) {
      mutable_heartbeat_config()->::mcs_proto::HeartbeatConfig::MergeFrom(from.heartbeat_config());
    }
    if (cached_has_bits & 0x00000010u) {
      stream_id_ = from.stream_id_;
    }
    if (cached_has_bits & 0x00000020u) {
      last_stream_id_received_ = from.last_stream_id_received_;
    }
    if (cached_has_bits & 0x00000040u) {
      server_timestamp_ = from.server_timestamp_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void LoginResponse::CopyFrom(const LoginResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:mcs_proto.LoginResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool LoginResponse::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
  if (!::google::protobuf::internal::AllAreInitialized(this->setting())) return false;
  if (has_error()) {
    if (!this->error_->IsInitialized()) return false;
  }
  return true;
}

void LoginResponse::Swap(LoginResponse* other) {
  if (other == this) return;
  InternalSwap(other);
}
void LoginResponse::InternalSwap(LoginResponse* other) {
  setting_.InternalSwap(&other->setting_);
  id_.Swap(&other->id_);
  jid_.Swap(&other->jid_);
  std::swap(error_, other->error_);
  std::swap(heartbeat_config_, other->heartbeat_config_);
  std::swap(stream_id_, other->stream_id_);
  std::swap(last_stream_id_received_, other->last_stream_id_received_);
  std::swap(server_timestamp_, other->server_timestamp_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string LoginResponse::GetTypeName() const {
  return "mcs_proto.LoginResponse";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// LoginResponse

// required string id = 1;
bool LoginResponse::has_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void LoginResponse::set_has_id() {
  _has_bits_[0] |= 0x00000001u;
}
void LoginResponse::clear_has_id() {
  _has_bits_[0] &= ~0x00000001u;
}
void LoginResponse::clear_id() {
  id_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_id();
}
const ::std::string& LoginResponse::id() const {
  // @@protoc_insertion_point(field_get:mcs_proto.LoginResponse.id)
  return id_.GetNoArena();
}
void LoginResponse::set_id(const ::std::string& value) {
  set_has_id();
  id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:mcs_proto.LoginResponse.id)
}
#if LANG_CXX11
void LoginResponse::set_id(::std::string&& value) {
  set_has_id();
  id_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:mcs_proto.LoginResponse.id)
}
#endif
void LoginResponse::set_id(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_id();
  id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:mcs_proto.LoginResponse.id)
}
void LoginResponse::set_id(const char* value, size_t size) {
  set_has_id();
  id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:mcs_proto.LoginResponse.id)
}
::std::string* LoginResponse::mutable_id() {
  set_has_id();
  // @@protoc_insertion_point(field_mutable:mcs_proto.LoginResponse.id)
  return id_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* LoginResponse::release_id() {
  // @@protoc_insertion_point(field_release:mcs_proto.LoginResponse.id)
  clear_has_id();
  return id_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void LoginResponse::set_allocated_id(::std::string* id) {
  if (id != NULL) {
    set_has_id();
  } else {
    clear_has_id();
  }
  id_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), id);
  // @@protoc_insertion_point(field_set_allocated:mcs_proto.LoginResponse.id)
}

// optional string jid = 2;
bool LoginResponse::has_jid() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void LoginResponse::set_has_jid() {
  _has_bits_[0] |= 0x00000002u;
}
void LoginResponse::clear_has_jid() {
  _has_bits_[0] &= ~0x00000002u;
}
void LoginResponse::clear_jid() {
  jid_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_jid();
}
const ::std::string& LoginResponse::jid() const {
  // @@protoc_insertion_point(field_get:mcs_proto.LoginResponse.jid)
  return jid_.GetNoArena();
}
void LoginResponse::set_jid(const ::std::string& value) {
  set_has_jid();
  jid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:mcs_proto.LoginResponse.jid)
}
#if LANG_CXX11
void LoginResponse::set_jid(::std::string&& value) {
  set_has_jid();
  jid_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:mcs_proto.LoginResponse.jid)
}
#endif
void LoginResponse::set_jid(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_jid();
  jid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:mcs_proto.LoginResponse.jid)
}
void LoginResponse::set_jid(const char* value, size_t size) {
  set_has_jid();
  jid_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:mcs_proto.LoginResponse.jid)
}
::std::string* LoginResponse::mutable_jid() {
  set_has_jid();
  // @@protoc_insertion_point(field_mutable:mcs_proto.LoginResponse.jid)
  return jid_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* LoginResponse::release_jid() {
  // @@protoc_insertion_point(field_release:mcs_proto.LoginResponse.jid)
  clear_has_jid();
  return jid_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void LoginResponse::set_allocated_jid(::std::string* jid) {
  if (jid != NULL) {
    set_has_jid();
  } else {
    clear_has_jid();
  }
  jid_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), jid);
  // @@protoc_insertion_point(field_set_allocated:mcs_proto.LoginResponse.jid)
}

// optional .mcs_proto.ErrorInfo error = 3;
bool LoginResponse::has_error() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
void LoginResponse::set_has_error() {
  _has_bits_[0] |= 0x00000004u;
}
void LoginResponse::clear_has_error() {
  _has_bits_[0] &= ~0x00000004u;
}
void LoginResponse::clear_error() {
  if (error_ != NULL) error_->::mcs_proto::ErrorInfo::Clear();
  clear_has_error();
}
const ::mcs_proto::ErrorInfo& LoginResponse::error() const {
  // @@protoc_insertion_point(field_get:mcs_proto.LoginResponse.error)
  return error_ != NULL ? *error_
                         : *::mcs_proto::ErrorInfo::internal_default_instance();
}
::mcs_proto::ErrorInfo* LoginResponse::mutable_error() {
  set_has_error();
  if (error_ == NULL) {
    error_ = new ::mcs_proto::ErrorInfo;
  }
  // @@protoc_insertion_point(field_mutable:mcs_proto.LoginResponse.error)
  return error_;
}
::mcs_proto::ErrorInfo* LoginResponse::release_error() {
  // @@protoc_insertion_point(field_release:mcs_proto.LoginResponse.error)
  clear_has_error();
  ::mcs_proto::ErrorInfo* temp = error_;
  error_ = NULL;
  return temp;
}
void LoginResponse::set_allocated_error(::mcs_proto::ErrorInfo* error) {
  delete error_;
  error_ = error;
  if (error) {
    set_has_error();
  } else {
    clear_has_error();
  }
  // @@protoc_insertion_point(field_set_allocated:mcs_proto.LoginResponse.error)
}

// repeated .mcs_proto.Setting setting = 4;
int LoginResponse::setting_size() const {
  return setting_.size();
}
void LoginResponse::clear_setting() {
  setting_.Clear();
}
const ::mcs_proto::Setting& LoginResponse::setting(int index) const {
  // @@protoc_insertion_point(field_get:mcs_proto.LoginResponse.setting)
  return setting_.Get(index);
}
::mcs_proto::Setting* LoginResponse::mutable_setting(int index) {
  // @@protoc_insertion_point(field_mutable:mcs_proto.LoginResponse.setting)
  return setting_.Mutable(index);
}
::mcs_proto::Setting* LoginResponse::add_setting() {
  // @@protoc_insertion_point(field_add:mcs_proto.LoginResponse.setting)
  return setting_.Add();
}
::google::protobuf::RepeatedPtrField< ::mcs_proto::Setting >*
LoginResponse::mutable_setting() {
  // @@protoc_insertion_point(field_mutable_list:mcs_proto.LoginResponse.setting)
  return &setting_;
}
const ::google::protobuf::RepeatedPtrField< ::mcs_proto::Setting >&
LoginResponse::setting() const {
  // @@protoc_insertion_point(field_list:mcs_proto.LoginResponse.setting)
  return setting_;
}

// optional int32 stream_id = 5;
bool LoginResponse::has_stream_id() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
void LoginResponse::set_has_stream_id() {
  _has_bits_[0] |= 0x00000010u;
}
void LoginResponse::clear_has_stream_id() {
  _has_bits_[0] &= ~0x00000010u;
}
void LoginResponse::clear_stream_id() {
  stream_id_ = 0;
  clear_has_stream_id();
}
::google::protobuf::int32 LoginResponse::stream_id() const {
  // @@protoc_insertion_point(field_get:mcs_proto.LoginResponse.stream_id)
  return stream_id_;
}
void LoginResponse::set_stream_id(::google::protobuf::int32 value) {
  set_has_stream_id();
  stream_id_ = value;
  // @@protoc_insertion_point(field_set:mcs_proto.LoginResponse.stream_id)
}

// optional int32 last_stream_id_received = 6;
bool LoginResponse::has_last_stream_id_received() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
void LoginResponse::set_has_last_stream_id_received() {
  _has_bits_[0] |= 0x00000020u;
}
void LoginResponse::clear_has_last_stream_id_received() {
  _has_bits_[0] &= ~0x00000020u;
}
void LoginResponse::clear_last_stream_id_received() {
  last_stream_id_received_ = 0;
  clear_has_last_stream_id_received();
}
::google::protobuf::int32 LoginResponse::last_stream_id_received() const {
  // @@protoc_insertion_point(field_get:mcs_proto.LoginResponse.last_stream_id_received)
  return last_stream_id_received_;
}
void LoginResponse::set_last_stream_id_received(::google::protobuf::int32 value) {
  set_has_last_stream_id_received();
  last_stream_id_received_ = value;
  // @@protoc_insertion_point(field_set:mcs_proto.LoginResponse.last_stream_id_received)
}

// optional .mcs_proto.HeartbeatConfig heartbeat_config = 7;
bool LoginResponse::has_heartbeat_config() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
void LoginResponse::set_has_heartbeat_config() {
  _has_bits_[0] |= 0x00000008u;
}
void LoginResponse::clear_has_heartbeat_config() {
  _has_bits_[0] &= ~0x00000008u;
}
void LoginResponse::clear_heartbeat_config() {
  if (heartbeat_config_ != NULL) heartbeat_config_->::mcs_proto::HeartbeatConfig::Clear();
  clear_has_heartbeat_config();
}
const ::mcs_proto::HeartbeatConfig& LoginResponse::heartbeat_config() const {
  // @@protoc_insertion_point(field_get:mcs_proto.LoginResponse.heartbeat_config)
  return heartbeat_config_ != NULL ? *heartbeat_config_
                         : *::mcs_proto::HeartbeatConfig::internal_default_instance();
}
::mcs_proto::HeartbeatConfig* LoginResponse::mutable_heartbeat_config() {
  set_has_heartbeat_config();
  if (heartbeat_config_ == NULL) {
    heartbeat_config_ = new ::mcs_proto::HeartbeatConfig;
  }
  // @@protoc_insertion_point(field_mutable:mcs_proto.LoginResponse.heartbeat_config)
  return heartbeat_config_;
}
::mcs_proto::HeartbeatConfig* LoginResponse::release_heartbeat_config() {
  // @@protoc_insertion_point(field_release:mcs_proto.LoginResponse.heartbeat_config)
  clear_has_heartbeat_config();
  ::mcs_proto::HeartbeatConfig* temp = heartbeat_config_;
  heartbeat_config_ = NULL;
  return temp;
}
void LoginResponse::set_allocated_heartbeat_config(::mcs_proto::HeartbeatConfig* heartbeat_config) {
  delete heartbeat_config_;
  heartbeat_config_ = heartbeat_config;
  if (heartbeat_config) {
    set_has_heartbeat_config();
  } else {
    clear_has_heartbeat_config();
  }
  // @@protoc_insertion_point(field_set_allocated:mcs_proto.LoginResponse.heartbeat_config)
}

// optional int64 server_timestamp = 8;
bool LoginResponse::has_server_timestamp() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
void LoginResponse::set_has_server_timestamp() {
  _has_bits_[0] |= 0x00000040u;
}
void LoginResponse::clear_has_server_timestamp() {
  _has_bits_[0] &= ~0x00000040u;
}
void LoginResponse::clear_server_timestamp() {
  server_timestamp_ = GOOGLE_LONGLONG(0);
  clear_has_server_timestamp();
}
::google::protobuf::int64 LoginResponse::server_timestamp() const {
  // @@protoc_insertion_point(field_get:mcs_proto.LoginResponse.server_timestamp)
  return server_timestamp_;
}
void LoginResponse::set_server_timestamp(::google::protobuf::int64 value) {
  set_has_server_timestamp();
  server_timestamp_ = value;
  // @@protoc_insertion_point(field_set:mcs_proto.LoginResponse.server_timestamp)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int StreamErrorStanza::kTypeFieldNumber;
const int StreamErrorStanza::kTextFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

StreamErrorStanza::StreamErrorStanza()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_mcs_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:mcs_proto.StreamErrorStanza)
}
StreamErrorStanza::StreamErrorStanza(const StreamErrorStanza& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  type_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_type()) {
    type_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.type_);
  }
  text_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_text()) {
    text_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.text_);
  }
  // @@protoc_insertion_point(copy_constructor:mcs_proto.StreamErrorStanza)
}

void StreamErrorStanza::SharedCtor() {
  _cached_size_ = 0;
  type_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  text_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}

StreamErrorStanza::~StreamErrorStanza() {
  // @@protoc_insertion_point(destructor:mcs_proto.StreamErrorStanza)
  SharedDtor();
}

void StreamErrorStanza::SharedDtor() {
  type_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  text_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}

void StreamErrorStanza::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const StreamErrorStanza& StreamErrorStanza::default_instance() {
  protobuf_mcs_2eproto::InitDefaults();
  return *internal_default_instance();
}

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

void StreamErrorStanza::Clear() {
// @@protoc_insertion_point(message_clear_start:mcs_proto.StreamErrorStanza)
  if (_has_bits_[0 / 32] & 3u) {
    if (has_type()) {
      GOOGLE_DCHECK(!type_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*type_.UnsafeRawStringPointer())->clear();
    }
    if (has_text()) {
      GOOGLE_DCHECK(!text_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*text_.UnsafeRawStringPointer())->clear();
    }
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool StreamErrorStanza::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:mcs_proto.StreamErrorStanza)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required string type = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_type()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional string text = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(18u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_text()));
        } else {
          goto handle_unusual;
        }
        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::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:mcs_proto.StreamErrorStanza)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:mcs_proto.StreamErrorStanza)
  return false;
#undef DO_
}

void StreamErrorStanza::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:mcs_proto.StreamErrorStanza)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required string type = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->type(), output);
  }

  // optional string text = 2;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      2, this->text(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:mcs_proto.StreamErrorStanza)
}

size_t StreamErrorStanza::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:mcs_proto.StreamErrorStanza)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  // required string type = 1;
  if (has_type()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::StringSize(
        this->type());
  }
  // optional string text = 2;
  if (has_text()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::StringSize(
        this->text());
  }

  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

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

void StreamErrorStanza::MergeFrom(const StreamErrorStanza& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:mcs_proto.StreamErrorStanza)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 3u) {
    if (cached_has_bits & 0x00000001u) {
      set_has_type();
      type_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.type_);
    }
    if (cached_has_bits & 0x00000002u) {
      set_has_text();
      text_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.text_);
    }
  }
}

void StreamErrorStanza::CopyFrom(const StreamErrorStanza& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:mcs_proto.StreamErrorStanza)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

::std::string StreamErrorStanza::GetTypeName() const {
  return "mcs_proto.StreamErrorStanza";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// StreamErrorStanza

// required string type = 1;
bool StreamErrorStanza::has_type() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void StreamErrorStanza::set_has_type() {
  _has_bits_[0] |= 0x00000001u;
}
void StreamErrorStanza::clear_has_type() {
  _has_bits_[0] &= ~0x00000001u;
}
void StreamErrorStanza::clear_type() {
  type_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_type();
}
const ::std::string& StreamErrorStanza::type() const {
  // @@protoc_insertion_point(field_get:mcs_proto.StreamErrorStanza.type)
  return type_.GetNoArena();
}
void StreamErrorStanza::set_type(const ::std::string& value) {
  set_has_type();
  type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:mcs_proto.StreamErrorStanza.type)
}
#if LANG_CXX11
void StreamErrorStanza::set_type(::std::string&& value) {
  set_has_type();
  type_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:mcs_proto.StreamErrorStanza.type)
}
#endif
void StreamErrorStanza::set_type(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_type();
  type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:mcs_proto.StreamErrorStanza.type)
}
void StreamErrorStanza::set_type(const char* value, size_t size) {
  set_has_type();
  type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:mcs_proto.StreamErrorStanza.type)
}
::std::string* StreamErrorStanza::mutable_type() {
  set_has_type();
  // @@protoc_insertion_point(field_mutable:mcs_proto.StreamErrorStanza.type)
  return type_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* StreamErrorStanza::release_type() {
  // @@protoc_insertion_point(field_release:mcs_proto.StreamErrorStanza.type)
  clear_has_type();
  return type_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void StreamErrorStanza::set_allocated_type(::std::string* type) {
  if (type != NULL) {
    set_has_type();
  } else {
    clear_has_type();
  }
  type_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), type);
  // @@protoc_insertion_point(field_set_allocated:mcs_proto.StreamErrorStanza.type)
}

// optional string text = 2;
bool StreamErrorStanza::has_text() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void StreamErrorStanza::set_has_text() {
  _has_bits_[0] |= 0x00000002u;
}
void StreamErrorStanza::clear_has_text() {
  _has_bits_[0] &= ~0x00000002u;
}
void StreamErrorStanza::clear_text() {
  text_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_text();
}
const ::std::string& StreamErrorStanza::text() const {
  // @@protoc_insertion_point(field_get:mcs_proto.StreamErrorStanza.text)
  return text_.GetNoArena();
}
void StreamErrorStanza::set_text(const ::std::string& value) {
  set_has_text();
  text_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:mcs_proto.StreamErrorStanza.text)
}
#if LANG_CXX11
void StreamErrorStanza::set_text(::std::string&& value) {
  set_has_text();
  text_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:mcs_proto.StreamErrorStanza.text)
}
#endif
void StreamErrorStanza::set_text(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_text();
  text_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:mcs_proto.StreamErrorStanza.text)
}
void StreamErrorStanza::set_text(const char* value, size_t size) {
  set_has_text();
  text_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:mcs_proto.StreamErrorStanza.text)
}
::std::string* StreamErrorStanza::mutable_text() {
  set_has_text();
  // @@protoc_insertion_point(field_mutable:mcs_proto.StreamErrorStanza.text)
  return text_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* StreamErrorStanza::release_text() {
  // @@protoc_insertion_point(field_release:mcs_proto.StreamErrorStanza.text)
  clear_has_text();
  return text_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void StreamErrorStanza::set_allocated_text(::std::string* text) {
  if (text != NULL) {
    set_has_text();
  } else {
    clear_has_text();
  }
  text_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), text);
  // @@protoc_insertion_point(field_set_allocated:mcs_proto.StreamErrorStanza.text)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

Close::Close()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_mcs_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:mcs_proto.Close)
}
Close::Close(const Close& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:mcs_proto.Close)
}

void Close::SharedCtor() {
  _cached_size_ = 0;
}

Close::~Close() {
  // @@protoc_insertion_point(destructor:mcs_proto.Close)
  SharedDtor();
}

void Close::SharedDtor() {
}

void Close::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const Close& Close::default_instance() {
  protobuf_mcs_2eproto::InitDefaults();
  return *internal_default_instance();
}

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

void Close::Clear() {
// @@protoc_insertion_point(message_clear_start:mcs_proto.Close)
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool Close::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:mcs_proto.Close)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
  handle_unusual:
    if (tag == 0 ||
        ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
        ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
      goto success;
    }
    DO_(::google::protobuf::internal::WireFormatLite::SkipField(
        input, tag, &unknown_fields_stream));
  }
success:
  // @@protoc_insertion_point(parse_success:mcs_proto.Close)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:mcs_proto.Close)
  return false;
#undef DO_
}

void Close::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:mcs_proto.Close)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:mcs_proto.Close)
}

size_t Close::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:mcs_proto.Close)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

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

void Close::MergeFrom(const Close& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:mcs_proto.Close)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

}

void Close::CopyFrom(const Close& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:mcs_proto.Close)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Close::IsInitialized() const {
  return true;
}

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

::std::string Close::GetTypeName() const {
  return "mcs_proto.Close";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// Close

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int Extension::kIdFieldNumber;
const int Extension::kDataFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

Extension::Extension()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_mcs_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:mcs_proto.Extension)
}
Extension::Extension(const Extension& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  data_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_data()) {
    data_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.data_);
  }
  id_ = from.id_;
  // @@protoc_insertion_point(copy_constructor:mcs_proto.Extension)
}

void Extension::SharedCtor() {
  _cached_size_ = 0;
  data_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  id_ = 0;
}

Extension::~Extension() {
  // @@protoc_insertion_point(destructor:mcs_proto.Extension)
  SharedDtor();
}

void Extension::SharedDtor() {
  data_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}

void Extension::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const Extension& Extension::default_instance() {
  protobuf_mcs_2eproto::InitDefaults();
  return *internal_default_instance();
}

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

void Extension::Clear() {
// @@protoc_insertion_point(message_clear_start:mcs_proto.Extension)
  if (has_data()) {
    GOOGLE_DCHECK(!data_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
    (*data_.UnsafeRawStringPointer())->clear();
  }
  id_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool Extension::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:mcs_proto.Extension)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required int32 id = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u)) {
          set_has_id();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &id_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // required bytes data = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(18u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_data()));
        } else {
          goto handle_unusual;
        }
        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::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:mcs_proto.Extension)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:mcs_proto.Extension)
  return false;
#undef DO_
}

void Extension::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:mcs_proto.Extension)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required int32 id = 1;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->id(), output);
  }

  // required bytes data = 2;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
      2, this->data(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:mcs_proto.Extension)
}

size_t Extension::RequiredFieldsByteSizeFallback() const {
// @@protoc_insertion_point(required_fields_byte_size_fallback_start:mcs_proto.Extension)
  size_t total_size = 0;

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

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

  return total_size;
}
size_t Extension::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:mcs_proto.Extension)
  size_t total_size = 0;

  total_size += unknown_fields().size();

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

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

  } else {
    total_size += RequiredFieldsByteSizeFallback();
  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

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

void Extension::MergeFrom(const Extension& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:mcs_proto.Extension)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 3u) {
    if (cached_has_bits & 0x00000001u) {
      set_has_data();
      data_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.data_);
    }
    if (cached_has_bits & 0x00000002u) {
      id_ = from.id_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void Extension::CopyFrom(const Extension& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:mcs_proto.Extension)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

::std::string Extension::GetTypeName() const {
  return "mcs_proto.Extension";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// Extension

// required int32 id = 1;
bool Extension::has_id() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void Extension::set_has_id() {
  _has_bits_[0] |= 0x00000002u;
}
void Extension::clear_has_id() {
  _has_bits_[0] &= ~0x00000002u;
}
void Extension::clear_id() {
  id_ = 0;
  clear_has_id();
}
::google::protobuf::int32 Extension::id() const {
  // @@protoc_insertion_point(field_get:mcs_proto.Extension.id)
  return id_;
}
void Extension::set_id(::google::protobuf::int32 value) {
  set_has_id();
  id_ = value;
  // @@protoc_insertion_point(field_set:mcs_proto.Extension.id)
}

// required bytes data = 2;
bool Extension::has_data() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void Extension::set_has_data() {
  _has_bits_[0] |= 0x00000001u;
}
void Extension::clear_has_data() {
  _has_bits_[0] &= ~0x00000001u;
}
void Extension::clear_data() {
  data_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_data();
}
const ::std::string& Extension::data() const {
  // @@protoc_insertion_point(field_get:mcs_proto.Extension.data)
  return data_.GetNoArena();
}
void Extension::set_data(const ::std::string& value) {
  set_has_data();
  data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:mcs_proto.Extension.data)
}
#if LANG_CXX11
void Extension::set_data(::std::string&& value) {
  set_has_data();
  data_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:mcs_proto.Extension.data)
}
#endif
void Extension::set_data(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_data();
  data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:mcs_proto.Extension.data)
}
void Extension::set_data(const void* value, size_t size) {
  set_has_data();
  data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:mcs_proto.Extension.data)
}
::std::string* Extension::mutable_data() {
  set_has_data();
  // @@protoc_insertion_point(field_mutable:mcs_proto.Extension.data)
  return data_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* Extension::release_data() {
  // @@protoc_insertion_point(field_release:mcs_proto.Extension.data)
  clear_has_data();
  return data_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void Extension::set_allocated_data(::std::string* data) {
  if (data != NULL) {
    set_has_data();
  } else {
    clear_has_data();
  }
  data_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), data);
  // @@protoc_insertion_point(field_set_allocated:mcs_proto.Extension.data)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int IqStanza::kRmqIdFieldNumber;
const int IqStanza::kTypeFieldNumber;
const int IqStanza::kIdFieldNumber;
const int IqStanza::kFromFieldNumber;
const int IqStanza::kToFieldNumber;
const int IqStanza::kErrorFieldNumber;
const int IqStanza::kExtensionFieldNumber;
const int IqStanza::kPersistentIdFieldNumber;
const int IqStanza::kStreamIdFieldNumber;
const int IqStanza::kLastStreamIdReceivedFieldNumber;
const int IqStanza::kAccountIdFieldNumber;
const int IqStanza::kStatusFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

IqStanza::IqStanza()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_mcs_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:mcs_proto.IqStanza)
}
IqStanza::IqStanza(const IqStanza& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_id()) {
    id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.id_);
  }
  from_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_from()) {
    from_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.from_);
  }
  to_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_to()) {
    to_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.to_);
  }
  persistent_id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_persistent_id()) {
    persistent_id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.persistent_id_);
  }
  if (from.has_error()) {
    error_ = new ::mcs_proto::ErrorInfo(*from.error_);
  } else {
    error_ = NULL;
  }
  if (from.has_extension()) {
    extension_ = new ::mcs_proto::Extension(*from.extension_);
  } else {
    extension_ = NULL;
  }
  ::memcpy(&rmq_id_, &from.rmq_id_,
    static_cast<size_t>(reinterpret_cast<char*>(&last_stream_id_received_) -
    reinterpret_cast<char*>(&rmq_id_)) + sizeof(last_stream_id_received_));
  // @@protoc_insertion_point(copy_constructor:mcs_proto.IqStanza)
}

void IqStanza::SharedCtor() {
  _cached_size_ = 0;
  id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  from_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  to_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  persistent_id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(&error_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&last_stream_id_received_) -
      reinterpret_cast<char*>(&error_)) + sizeof(last_stream_id_received_));
}

IqStanza::~IqStanza() {
  // @@protoc_insertion_point(destructor:mcs_proto.IqStanza)
  SharedDtor();
}

void IqStanza::SharedDtor() {
  id_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  from_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  to_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  persistent_id_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (this != internal_default_instance()) {
    delete error_;
  }
  if (this != internal_default_instance()) {
    delete extension_;
  }
}

void IqStanza::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const IqStanza& IqStanza::default_instance() {
  protobuf_mcs_2eproto::InitDefaults();
  return *internal_default_instance();
}

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

void IqStanza::Clear() {
// @@protoc_insertion_point(message_clear_start:mcs_proto.IqStanza)
  if (_has_bits_[0 / 32] & 63u) {
    if (has_id()) {
      GOOGLE_DCHECK(!id_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*id_.UnsafeRawStringPointer())->clear();
    }
    if (has_from()) {
      GOOGLE_DCHECK(!from_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*from_.UnsafeRawStringPointer())->clear();
    }
    if (has_to()) {
      GOOGLE_DCHECK(!to_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*to_.UnsafeRawStringPointer())->clear();
    }
    if (has_persistent_id()) {
      GOOGLE_DCHECK(!persistent_id_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*persistent_id_.UnsafeRawStringPointer())->clear();
    }
    if (has_error()) {
      GOOGLE_DCHECK(error_ != NULL);
      error_->::mcs_proto::ErrorInfo::Clear();
    }
    if (has_extension()) {
      GOOGLE_DCHECK(extension_ != NULL);
      extension_->::mcs_proto::Extension::Clear();
    }
  }
  if (_has_bits_[0 / 32] & 192u) {
    ::memset(&rmq_id_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&type_) -
        reinterpret_cast<char*>(&rmq_id_)) + sizeof(type_));
  }
  if (_has_bits_[8 / 32] & 3840u) {
    ::memset(&stream_id_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&last_stream_id_received_) -
        reinterpret_cast<char*>(&stream_id_)) + sizeof(last_stream_id_received_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool IqStanza::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:mcs_proto.IqStanza)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int64 rmq_id = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u)) {
          set_has_rmq_id();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &rmq_id_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // required .mcs_proto.IqStanza.IqType type = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::mcs_proto::IqStanza_IqType_IsValid(value)) {
            set_type(static_cast< ::mcs_proto::IqStanza_IqType >(value));
          } else {
            unknown_fields_stream.WriteVarint32(16u);
            unknown_fields_stream.WriteVarint32(
                static_cast< ::google::protobuf::uint32>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // required string id = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(26u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_id()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional string from = 4;
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(34u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_from()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional string to = 5;
      case 5: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(42u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_to()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .mcs_proto.ErrorInfo error = 6;
      case 6: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(50u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_error()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .mcs_proto.Extension extension = 7;
      case 7: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(58u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_extension()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional string persistent_id = 8;
      case 8: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(66u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_persistent_id()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 stream_id = 9;
      case 9: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(72u)) {
          set_has_stream_id();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &stream_id_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 last_stream_id_received = 10;
      case 10: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(80u)) {
          set_has_last_stream_id_received();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &last_stream_id_received_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int64 account_id = 11;
      case 11: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(88u)) {
          set_has_account_id();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &account_id_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int64 status = 12;
      case 12: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(96u)) {
          set_has_status();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &status_)));
        } else {
          goto handle_unusual;
        }
        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::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:mcs_proto.IqStanza)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:mcs_proto.IqStanza)
  return false;
#undef DO_
}

void IqStanza::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:mcs_proto.IqStanza)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int64 rmq_id = 1;
  if (cached_has_bits & 0x00000040u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(1, this->rmq_id(), output);
  }

  // required .mcs_proto.IqStanza.IqType type = 2;
  if (cached_has_bits & 0x00000080u) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      2, this->type(), output);
  }

  // required string id = 3;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      3, this->id(), output);
  }

  // optional string from = 4;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      4, this->from(), output);
  }

  // optional string to = 5;
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      5, this->to(), output);
  }

  // optional .mcs_proto.ErrorInfo error = 6;
  if (cached_has_bits & 0x00000010u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      6, *this->error_, output);
  }

  // optional .mcs_proto.Extension extension = 7;
  if (cached_has_bits & 0x00000020u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      7, *this->extension_, output);
  }

  // optional string persistent_id = 8;
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      8, this->persistent_id(), output);
  }

  // optional int32 stream_id = 9;
  if (cached_has_bits & 0x00000100u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(9, this->stream_id(), output);
  }

  // optional int32 last_stream_id_received = 10;
  if (cached_has_bits & 0x00000800u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(10, this->last_stream_id_received(), output);
  }

  // optional int64 account_id = 11;
  if (cached_has_bits & 0x00000200u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(11, this->account_id(), output);
  }

  // optional int64 status = 12;
  if (cached_has_bits & 0x00000400u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(12, this->status(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:mcs_proto.IqStanza)
}

size_t IqStanza::RequiredFieldsByteSizeFallback() const {
// @@protoc_insertion_point(required_fields_byte_size_fallback_start:mcs_proto.IqStanza)
  size_t total_size = 0;

  if (has_id()) {
    // required string id = 3;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::StringSize(
        this->id());
  }

  if (has_type()) {
    // required .mcs_proto.IqStanza.IqType type = 2;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::EnumSize(this->type());
  }

  return total_size;
}
size_t IqStanza::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:mcs_proto.IqStanza)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  if (((_has_bits_[0] & 0x00000081) ^ 0x00000081) == 0) {  // All required fields are present.
    // required string id = 3;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::StringSize(
        this->id());

    // required .mcs_proto.IqStanza.IqType type = 2;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::EnumSize(this->type());

  } else {
    total_size += RequiredFieldsByteSizeFallback();
  }
  if (_has_bits_[0 / 32] & 126u) {
    // optional string from = 4;
    if (has_from()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->from());
    }

    // optional string to = 5;
    if (has_to()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->to());
    }

    // optional string persistent_id = 8;
    if (has_persistent_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->persistent_id());
    }

    // optional .mcs_proto.ErrorInfo error = 6;
    if (has_error()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *this->error_);
    }

    // optional .mcs_proto.Extension extension = 7;
    if (has_extension()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *this->extension_);
    }

    // optional int64 rmq_id = 1;
    if (has_rmq_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->rmq_id());
    }

  }
  if (_has_bits_[8 / 32] & 3840u) {
    // optional int32 stream_id = 9;
    if (has_stream_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->stream_id());
    }

    // optional int64 account_id = 11;
    if (has_account_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->account_id());
    }

    // optional int64 status = 12;
    if (has_status()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->status());
    }

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

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

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

void IqStanza::MergeFrom(const IqStanza& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:mcs_proto.IqStanza)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 255u) {
    if (cached_has_bits & 0x00000001u) {
      set_has_id();
      id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.id_);
    }
    if (cached_has_bits & 0x00000002u) {
      set_has_from();
      from_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.from_);
    }
    if (cached_has_bits & 0x00000004u) {
      set_has_to();
      to_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.to_);
    }
    if (cached_has_bits & 0x00000008u) {
      set_has_persistent_id();
      persistent_id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.persistent_id_);
    }
    if (cached_has_bits & 0x00000010u) {
      mutable_error()->::mcs_proto::ErrorInfo::MergeFrom(from.error());
    }
    if (cached_has_bits & 0x00000020u) {
      mutable_extension()->::mcs_proto::Extension::MergeFrom(from.extension());
    }
    if (cached_has_bits & 0x00000040u) {
      rmq_id_ = from.rmq_id_;
    }
    if (cached_has_bits & 0x00000080u) {
      type_ = from.type_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  if (cached_has_bits & 3840u) {
    if (cached_has_bits & 0x00000100u) {
      stream_id_ = from.stream_id_;
    }
    if (cached_has_bits & 0x00000200u) {
      account_id_ = from.account_id_;
    }
    if (cached_has_bits & 0x00000400u) {
      status_ = from.status_;
    }
    if (cached_has_bits & 0x00000800u) {
      last_stream_id_received_ = from.last_stream_id_received_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void IqStanza::CopyFrom(const IqStanza& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:mcs_proto.IqStanza)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool IqStanza::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000081) != 0x00000081) return false;
  if (has_error()) {
    if (!this->error_->IsInitialized()) return false;
  }
  if (has_extension()) {
    if (!this->extension_->IsInitialized()) return false;
  }
  return true;
}

void IqStanza::Swap(IqStanza* other) {
  if (other == this) return;
  InternalSwap(other);
}
void IqStanza::InternalSwap(IqStanza* other) {
  id_.Swap(&other->id_);
  from_.Swap(&other->from_);
  to_.Swap(&other->to_);
  persistent_id_.Swap(&other->persistent_id_);
  std::swap(error_, other->error_);
  std::swap(extension_, other->extension_);
  std::swap(rmq_id_, other->rmq_id_);
  std::swap(type_, other->type_);
  std::swap(stream_id_, other->stream_id_);
  std::swap(account_id_, other->account_id_);
  std::swap(status_, other->status_);
  std::swap(last_stream_id_received_, other->last_stream_id_received_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string IqStanza::GetTypeName() const {
  return "mcs_proto.IqStanza";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// IqStanza

// optional int64 rmq_id = 1;
bool IqStanza::has_rmq_id() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
void IqStanza::set_has_rmq_id() {
  _has_bits_[0] |= 0x00000040u;
}
void IqStanza::clear_has_rmq_id() {
  _has_bits_[0] &= ~0x00000040u;
}
void IqStanza::clear_rmq_id() {
  rmq_id_ = GOOGLE_LONGLONG(0);
  clear_has_rmq_id();
}
::google::protobuf::int64 IqStanza::rmq_id() const {
  // @@protoc_insertion_point(field_get:mcs_proto.IqStanza.rmq_id)
  return rmq_id_;
}
void IqStanza::set_rmq_id(::google::protobuf::int64 value) {
  set_has_rmq_id();
  rmq_id_ = value;
  // @@protoc_insertion_point(field_set:mcs_proto.IqStanza.rmq_id)
}

// required .mcs_proto.IqStanza.IqType type = 2;
bool IqStanza::has_type() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
void IqStanza::set_has_type() {
  _has_bits_[0] |= 0x00000080u;
}
void IqStanza::clear_has_type() {
  _has_bits_[0] &= ~0x00000080u;
}
void IqStanza::clear_type() {
  type_ = 0;
  clear_has_type();
}
::mcs_proto::IqStanza_IqType IqStanza::type() const {
  // @@protoc_insertion_point(field_get:mcs_proto.IqStanza.type)
  return static_cast< ::mcs_proto::IqStanza_IqType >(type_);
}
void IqStanza::set_type(::mcs_proto::IqStanza_IqType value) {
  assert(::mcs_proto::IqStanza_IqType_IsValid(value));
  set_has_type();
  type_ = value;
  // @@protoc_insertion_point(field_set:mcs_proto.IqStanza.type)
}

// required string id = 3;
bool IqStanza::has_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void IqStanza::set_has_id() {
  _has_bits_[0] |= 0x00000001u;
}
void IqStanza::clear_has_id() {
  _has_bits_[0] &= ~0x00000001u;
}
void IqStanza::clear_id() {
  id_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_id();
}
const ::std::string& IqStanza::id() const {
  // @@protoc_insertion_point(field_get:mcs_proto.IqStanza.id)
  return id_.GetNoArena();
}
void IqStanza::set_id(const ::std::string& value) {
  set_has_id();
  id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:mcs_proto.IqStanza.id)
}
#if LANG_CXX11
void IqStanza::set_id(::std::string&& value) {
  set_has_id();
  id_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:mcs_proto.IqStanza.id)
}
#endif
void IqStanza::set_id(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_id();
  id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:mcs_proto.IqStanza.id)
}
void IqStanza::set_id(const char* value, size_t size) {
  set_has_id();
  id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:mcs_proto.IqStanza.id)
}
::std::string* IqStanza::mutable_id() {
  set_has_id();
  // @@protoc_insertion_point(field_mutable:mcs_proto.IqStanza.id)
  return id_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* IqStanza::release_id() {
  // @@protoc_insertion_point(field_release:mcs_proto.IqStanza.id)
  clear_has_id();
  return id_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void IqStanza::set_allocated_id(::std::string* id) {
  if (id != NULL) {
    set_has_id();
  } else {
    clear_has_id();
  }
  id_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), id);
  // @@protoc_insertion_point(field_set_allocated:mcs_proto.IqStanza.id)
}

// optional string from = 4;
bool IqStanza::has_from() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void IqStanza::set_has_from() {
  _has_bits_[0] |= 0x00000002u;
}
void IqStanza::clear_has_from() {
  _has_bits_[0] &= ~0x00000002u;
}
void IqStanza::clear_from() {
  from_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_from();
}
const ::std::string& IqStanza::from() const {
  // @@protoc_insertion_point(field_get:mcs_proto.IqStanza.from)
  return from_.GetNoArena();
}
void IqStanza::set_from(const ::std::string& value) {
  set_has_from();
  from_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:mcs_proto.IqStanza.from)
}
#if LANG_CXX11
void IqStanza::set_from(::std::string&& value) {
  set_has_from();
  from_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:mcs_proto.IqStanza.from)
}
#endif
void IqStanza::set_from(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_from();
  from_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:mcs_proto.IqStanza.from)
}
void IqStanza::set_from(const char* value, size_t size) {
  set_has_from();
  from_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:mcs_proto.IqStanza.from)
}
::std::string* IqStanza::mutable_from() {
  set_has_from();
  // @@protoc_insertion_point(field_mutable:mcs_proto.IqStanza.from)
  return from_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* IqStanza::release_from() {
  // @@protoc_insertion_point(field_release:mcs_proto.IqStanza.from)
  clear_has_from();
  return from_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void IqStanza::set_allocated_from(::std::string* from) {
  if (from != NULL) {
    set_has_from();
  } else {
    clear_has_from();
  }
  from_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from);
  // @@protoc_insertion_point(field_set_allocated:mcs_proto.IqStanza.from)
}

// optional string to = 5;
bool IqStanza::has_to() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
void IqStanza::set_has_to() {
  _has_bits_[0] |= 0x00000004u;
}
void IqStanza::clear_has_to() {
  _has_bits_[0] &= ~0x00000004u;
}
void IqStanza::clear_to() {
  to_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_to();
}
const ::std::string& IqStanza::to() const {
  // @@protoc_insertion_point(field_get:mcs_proto.IqStanza.to)
  return to_.GetNoArena();
}
void IqStanza::set_to(const ::std::string& value) {
  set_has_to();
  to_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:mcs_proto.IqStanza.to)
}
#if LANG_CXX11
void IqStanza::set_to(::std::string&& value) {
  set_has_to();
  to_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:mcs_proto.IqStanza.to)
}
#endif
void IqStanza::set_to(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_to();
  to_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:mcs_proto.IqStanza.to)
}
void IqStanza::set_to(const char* value, size_t size) {
  set_has_to();
  to_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:mcs_proto.IqStanza.to)
}
::std::string* IqStanza::mutable_to() {
  set_has_to();
  // @@protoc_insertion_point(field_mutable:mcs_proto.IqStanza.to)
  return to_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* IqStanza::release_to() {
  // @@protoc_insertion_point(field_release:mcs_proto.IqStanza.to)
  clear_has_to();
  return to_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void IqStanza::set_allocated_to(::std::string* to) {
  if (to != NULL) {
    set_has_to();
  } else {
    clear_has_to();
  }
  to_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), to);
  // @@protoc_insertion_point(field_set_allocated:mcs_proto.IqStanza.to)
}

// optional .mcs_proto.ErrorInfo error = 6;
bool IqStanza::has_error() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
void IqStanza::set_has_error() {
  _has_bits_[0] |= 0x00000010u;
}
void IqStanza::clear_has_error() {
  _has_bits_[0] &= ~0x00000010u;
}
void IqStanza::clear_error() {
  if (error_ != NULL) error_->::mcs_proto::ErrorInfo::Clear();
  clear_has_error();
}
const ::mcs_proto::ErrorInfo& IqStanza::error() const {
  // @@protoc_insertion_point(field_get:mcs_proto.IqStanza.error)
  return error_ != NULL ? *error_
                         : *::mcs_proto::ErrorInfo::internal_default_instance();
}
::mcs_proto::ErrorInfo* IqStanza::mutable_error() {
  set_has_error();
  if (error_ == NULL) {
    error_ = new ::mcs_proto::ErrorInfo;
  }
  // @@protoc_insertion_point(field_mutable:mcs_proto.IqStanza.error)
  return error_;
}
::mcs_proto::ErrorInfo* IqStanza::release_error() {
  // @@protoc_insertion_point(field_release:mcs_proto.IqStanza.error)
  clear_has_error();
  ::mcs_proto::ErrorInfo* temp = error_;
  error_ = NULL;
  return temp;
}
void IqStanza::set_allocated_error(::mcs_proto::ErrorInfo* error) {
  delete error_;
  error_ = error;
  if (error) {
    set_has_error();
  } else {
    clear_has_error();
  }
  // @@protoc_insertion_point(field_set_allocated:mcs_proto.IqStanza.error)
}

// optional .mcs_proto.Extension extension = 7;
bool IqStanza::has_extension() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
void IqStanza::set_has_extension() {
  _has_bits_[0] |= 0x00000020u;
}
void IqStanza::clear_has_extension() {
  _has_bits_[0] &= ~0x00000020u;
}
void IqStanza::clear_extension() {
  if (extension_ != NULL) extension_->::mcs_proto::Extension::Clear();
  clear_has_extension();
}
const ::mcs_proto::Extension& IqStanza::extension() const {
  // @@protoc_insertion_point(field_get:mcs_proto.IqStanza.extension)
  return extension_ != NULL ? *extension_
                         : *::mcs_proto::Extension::internal_default_instance();
}
::mcs_proto::Extension* IqStanza::mutable_extension() {
  set_has_extension();
  if (extension_ == NULL) {
    extension_ = new ::mcs_proto::Extension;
  }
  // @@protoc_insertion_point(field_mutable:mcs_proto.IqStanza.extension)
  return extension_;
}
::mcs_proto::Extension* IqStanza::release_extension() {
  // @@protoc_insertion_point(field_release:mcs_proto.IqStanza.extension)
  clear_has_extension();
  ::mcs_proto::Extension* temp = extension_;
  extension_ = NULL;
  return temp;
}
void IqStanza::set_allocated_extension(::mcs_proto::Extension* extension) {
  delete extension_;
  extension_ = extension;
  if (extension) {
    set_has_extension();
  } else {
    clear_has_extension();
  }
  // @@protoc_insertion_point(field_set_allocated:mcs_proto.IqStanza.extension)
}

// optional string persistent_id = 8;
bool IqStanza::has_persistent_id() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
void IqStanza::set_has_persistent_id() {
  _has_bits_[0] |= 0x00000008u;
}
void IqStanza::clear_has_persistent_id() {
  _has_bits_[0] &= ~0x00000008u;
}
void IqStanza::clear_persistent_id() {
  persistent_id_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_persistent_id();
}
const ::std::string& IqStanza::persistent_id() const {
  // @@protoc_insertion_point(field_get:mcs_proto.IqStanza.persistent_id)
  return persistent_id_.GetNoArena();
}
void IqStanza::set_persistent_id(const ::std::string& value) {
  set_has_persistent_id();
  persistent_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:mcs_proto.IqStanza.persistent_id)
}
#if LANG_CXX11
void IqStanza::set_persistent_id(::std::string&& value) {
  set_has_persistent_id();
  persistent_id_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:mcs_proto.IqStanza.persistent_id)
}
#endif
void IqStanza::set_persistent_id(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_persistent_id();
  persistent_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:mcs_proto.IqStanza.persistent_id)
}
void IqStanza::set_persistent_id(const char* value, size_t size) {
  set_has_persistent_id();
  persistent_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:mcs_proto.IqStanza.persistent_id)
}
::std::string* IqStanza::mutable_persistent_id() {
  set_has_persistent_id();
  // @@protoc_insertion_point(field_mutable:mcs_proto.IqStanza.persistent_id)
  return persistent_id_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* IqStanza::release_persistent_id() {
  // @@protoc_insertion_point(field_release:mcs_proto.IqStanza.persistent_id)
  clear_has_persistent_id();
  return persistent_id_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void IqStanza::set_allocated_persistent_id(::std::string* persistent_id) {
  if (persistent_id != NULL) {
    set_has_persistent_id();
  } else {
    clear_has_persistent_id();
  }
  persistent_id_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), persistent_id);
  // @@protoc_insertion_point(field_set_allocated:mcs_proto.IqStanza.persistent_id)
}

// optional int32 stream_id = 9;
bool IqStanza::has_stream_id() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
void IqStanza::set_has_stream_id() {
  _has_bits_[0] |= 0x00000100u;
}
void IqStanza::clear_has_stream_id() {
  _has_bits_[0] &= ~0x00000100u;
}
void IqStanza::clear_stream_id() {
  stream_id_ = 0;
  clear_has_stream_id();
}
::google::protobuf::int32 IqStanza::stream_id() const {
  // @@protoc_insertion_point(field_get:mcs_proto.IqStanza.stream_id)
  return stream_id_;
}
void IqStanza::set_stream_id(::google::protobuf::int32 value) {
  set_has_stream_id();
  stream_id_ = value;
  // @@protoc_insertion_point(field_set:mcs_proto.IqStanza.stream_id)
}

// optional int32 last_stream_id_received = 10;
bool IqStanza::has_last_stream_id_received() const {
  return (_has_bits_[0] & 0x00000800u) != 0;
}
void IqStanza::set_has_last_stream_id_received() {
  _has_bits_[0] |= 0x00000800u;
}
void IqStanza::clear_has_last_stream_id_received() {
  _has_bits_[0] &= ~0x00000800u;
}
void IqStanza::clear_last_stream_id_received() {
  last_stream_id_received_ = 0;
  clear_has_last_stream_id_received();
}
::google::protobuf::int32 IqStanza::last_stream_id_received() const {
  // @@protoc_insertion_point(field_get:mcs_proto.IqStanza.last_stream_id_received)
  return last_stream_id_received_;
}
void IqStanza::set_last_stream_id_received(::google::protobuf::int32 value) {
  set_has_last_stream_id_received();
  last_stream_id_received_ = value;
  // @@protoc_insertion_point(field_set:mcs_proto.IqStanza.last_stream_id_received)
}

// optional int64 account_id = 11;
bool IqStanza::has_account_id() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
void IqStanza::set_has_account_id() {
  _has_bits_[0] |= 0x00000200u;
}
void IqStanza::clear_has_account_id() {
  _has_bits_[0] &= ~0x00000200u;
}
void IqStanza::clear_account_id() {
  account_id_ = GOOGLE_LONGLONG(0);
  clear_has_account_id();
}
::google::protobuf::int64 IqStanza::account_id() const {
  // @@protoc_insertion_point(field_get:mcs_proto.IqStanza.account_id)
  return account_id_;
}
void IqStanza::set_account_id(::google::protobuf::int64 value) {
  set_has_account_id();
  account_id_ = value;
  // @@protoc_insertion_point(field_set:mcs_proto.IqStanza.account_id)
}

// optional int64 status = 12;
bool IqStanza::has_status() const {
  return (_has_bits_[0] & 0x00000400u) != 0;
}
void IqStanza::set_has_status() {
  _has_bits_[0] |= 0x00000400u;
}
void IqStanza::clear_has_status() {
  _has_bits_[0] &= ~0x00000400u;
}
void IqStanza::clear_status() {
  status_ = GOOGLE_LONGLONG(0);
  clear_has_status();
}
::google::protobuf::int64 IqStanza::status() const {
  // @@protoc_insertion_point(field_get:mcs_proto.IqStanza.status)
  return status_;
}
void IqStanza::set_status(::google::protobuf::int64 value) {
  set_has_status();
  status_ = value;
  // @@protoc_insertion_point(field_set:mcs_proto.IqStanza.status)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int AppData::kKeyFieldNumber;
const int AppData::kValueFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

AppData::AppData()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_mcs_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:mcs_proto.AppData)
}
AppData::AppData(const AppData& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  key_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_key()) {
    key_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.key_);
  }
  value_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_value()) {
    value_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.value_);
  }
  // @@protoc_insertion_point(copy_constructor:mcs_proto.AppData)
}

void AppData::SharedCtor() {
  _cached_size_ = 0;
  key_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  value_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}

AppData::~AppData() {
  // @@protoc_insertion_point(destructor:mcs_proto.AppData)
  SharedDtor();
}

void AppData::SharedDtor() {
  key_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  value_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}

void AppData::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const AppData& AppData::default_instance() {
  protobuf_mcs_2eproto::InitDefaults();
  return *internal_default_instance();
}

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

void AppData::Clear() {
// @@protoc_insertion_point(message_clear_start:mcs_proto.AppData)
  if (_has_bits_[0 / 32] & 3u) {
    if (has_key()) {
      GOOGLE_DCHECK(!key_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*key_.UnsafeRawStringPointer())->clear();
    }
    if (has_value()) {
      GOOGLE_DCHECK(!value_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*value_.UnsafeRawStringPointer())->clear();
    }
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool AppData::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:mcs_proto.AppData)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required string key = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_key()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // required string value = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(18u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_value()));
        } else {
          goto handle_unusual;
        }
        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::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:mcs_proto.AppData)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:mcs_proto.AppData)
  return false;
#undef DO_
}

void AppData::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:mcs_proto.AppData)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required string key = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->key(), output);
  }

  // required string value = 2;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      2, this->value(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:mcs_proto.AppData)
}

size_t AppData::RequiredFieldsByteSizeFallback() const {
// @@protoc_insertion_point(required_fields_byte_size_fallback_start:mcs_proto.AppData)
  size_t total_size = 0;

  if (has_key()) {
    // required string key = 1;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::StringSize(
        this->key());
  }

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

  return total_size;
}
size_t AppData::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:mcs_proto.AppData)
  size_t total_size = 0;

  total_size += unknown_fields().size();

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

    // required string value = 2;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::StringSize(
        this->value());

  } else {
    total_size += RequiredFieldsByteSizeFallback();
  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

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

void AppData::MergeFrom(const AppData& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:mcs_proto.AppData)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 3u) {
    if (cached_has_bits & 0x00000001u) {
      set_has_key();
      key_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.key_);
    }
    if (cached_has_bits & 0x00000002u) {
      set_has_value();
      value_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.value_);
    }
  }
}

void AppData::CopyFrom(const AppData& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:mcs_proto.AppData)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

::std::string AppData::GetTypeName() const {
  return "mcs_proto.AppData";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// AppData

// required string key = 1;
bool AppData::has_key() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void AppData::set_has_key() {
  _has_bits_[0] |= 0x00000001u;
}
void AppData::clear_has_key() {
  _has_bits_[0] &= ~0x00000001u;
}
void AppData::clear_key() {
  key_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_key();
}
const ::std::string& AppData::key() const {
  // @@protoc_insertion_point(field_get:mcs_proto.AppData.key)
  return key_.GetNoArena();
}
void AppData::set_key(const ::std::string& value) {
  set_has_key();
  key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:mcs_proto.AppData.key)
}
#if LANG_CXX11
void AppData::set_key(::std::string&& value) {
  set_has_key();
  key_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:mcs_proto.AppData.key)
}
#endif
void AppData::set_key(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_key();
  key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:mcs_proto.AppData.key)
}
void AppData::set_key(const char* value, size_t size) {
  set_has_key();
  key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:mcs_proto.AppData.key)
}
::std::string* AppData::mutable_key() {
  set_has_key();
  // @@protoc_insertion_point(field_mutable:mcs_proto.AppData.key)
  return key_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* AppData::release_key() {
  // @@protoc_insertion_point(field_release:mcs_proto.AppData.key)
  clear_has_key();
  return key_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void AppData::set_allocated_key(::std::string* key) {
  if (key != NULL) {
    set_has_key();
  } else {
    clear_has_key();
  }
  key_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), key);
  // @@protoc_insertion_point(field_set_allocated:mcs_proto.AppData.key)
}

// required string value = 2;
bool AppData::has_value() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void AppData::set_has_value() {
  _has_bits_[0] |= 0x00000002u;
}
void AppData::clear_has_value() {
  _has_bits_[0] &= ~0x00000002u;
}
void AppData::clear_value() {
  value_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_value();
}
const ::std::string& AppData::value() const {
  // @@protoc_insertion_point(field_get:mcs_proto.AppData.value)
  return value_.GetNoArena();
}
void AppData::set_value(const ::std::string& value) {
  set_has_value();
  value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:mcs_proto.AppData.value)
}
#if LANG_CXX11
void AppData::set_value(::std::string&& value) {
  set_has_value();
  value_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:mcs_proto.AppData.value)
}
#endif
void AppData::set_value(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_value();
  value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:mcs_proto.AppData.value)
}
void AppData::set_value(const char* value, size_t size) {
  set_has_value();
  value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:mcs_proto.AppData.value)
}
::std::string* AppData::mutable_value() {
  set_has_value();
  // @@protoc_insertion_point(field_mutable:mcs_proto.AppData.value)
  return value_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* AppData::release_value() {
  // @@protoc_insertion_point(field_release:mcs_proto.AppData.value)
  clear_has_value();
  return value_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void AppData::set_allocated_value(::std::string* value) {
  if (value != NULL) {
    set_has_value();
  } else {
    clear_has_value();
  }
  value_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set_allocated:mcs_proto.AppData.value)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int DataMessageStanza::kIdFieldNumber;
const int DataMessageStanza::kFromFieldNumber;
const int DataMessageStanza::kToFieldNumber;
const int DataMessageStanza::kCategoryFieldNumber;
const int DataMessageStanza::kTokenFieldNumber;
const int DataMessageStanza::kAppDataFieldNumber;
const int DataMessageStanza::kFromTrustedServerFieldNumber;
const int DataMessageStanza::kPersistentIdFieldNumber;
const int DataMessageStanza::kStreamIdFieldNumber;
const int DataMessageStanza::kLastStreamIdReceivedFieldNumber;
const int DataMessageStanza::kRegIdFieldNumber;
const int DataMessageStanza::kDeviceUserIdFieldNumber;
const int DataMessageStanza::kTtlFieldNumber;
const int DataMessageStanza::kSentFieldNumber;
const int DataMessageStanza::kQueuedFieldNumber;
const int DataMessageStanza::kStatusFieldNumber;
const int DataMessageStanza::kRawDataFieldNumber;
const int DataMessageStanza::kImmediateAckFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

DataMessageStanza::DataMessageStanza()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_mcs_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:mcs_proto.DataMessageStanza)
}
DataMessageStanza::DataMessageStanza(const DataMessageStanza& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0),
      app_data_(from.app_data_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_id()) {
    id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.id_);
  }
  from_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_from()) {
    from_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.from_);
  }
  to_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_to()) {
    to_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.to_);
  }
  category_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_category()) {
    category_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.category_);
  }
  token_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_token()) {
    token_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.token_);
  }
  persistent_id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_persistent_id()) {
    persistent_id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.persistent_id_);
  }
  reg_id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_reg_id()) {
    reg_id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.reg_id_);
  }
  raw_data_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_raw_data()) {
    raw_data_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.raw_data_);
  }
  ::memcpy(&stream_id_, &from.stream_id_,
    static_cast<size_t>(reinterpret_cast<char*>(&status_) -
    reinterpret_cast<char*>(&stream_id_)) + sizeof(status_));
  // @@protoc_insertion_point(copy_constructor:mcs_proto.DataMessageStanza)
}

void DataMessageStanza::SharedCtor() {
  _cached_size_ = 0;
  id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  from_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  to_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  category_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  token_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  persistent_id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  reg_id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  raw_data_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(&stream_id_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&status_) -
      reinterpret_cast<char*>(&stream_id_)) + sizeof(status_));
}

DataMessageStanza::~DataMessageStanza() {
  // @@protoc_insertion_point(destructor:mcs_proto.DataMessageStanza)
  SharedDtor();
}

void DataMessageStanza::SharedDtor() {
  id_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  from_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  to_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  category_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  token_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  persistent_id_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  reg_id_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  raw_data_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}

void DataMessageStanza::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const DataMessageStanza& DataMessageStanza::default_instance() {
  protobuf_mcs_2eproto::InitDefaults();
  return *internal_default_instance();
}

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

void DataMessageStanza::Clear() {
// @@protoc_insertion_point(message_clear_start:mcs_proto.DataMessageStanza)
  app_data_.Clear();
  if (_has_bits_[0 / 32] & 255u) {
    if (has_id()) {
      GOOGLE_DCHECK(!id_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*id_.UnsafeRawStringPointer())->clear();
    }
    if (has_from()) {
      GOOGLE_DCHECK(!from_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*from_.UnsafeRawStringPointer())->clear();
    }
    if (has_to()) {
      GOOGLE_DCHECK(!to_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*to_.UnsafeRawStringPointer())->clear();
    }
    if (has_category()) {
      GOOGLE_DCHECK(!category_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*category_.UnsafeRawStringPointer())->clear();
    }
    if (has_token()) {
      GOOGLE_DCHECK(!token_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*token_.UnsafeRawStringPointer())->clear();
    }
    if (has_persistent_id()) {
      GOOGLE_DCHECK(!persistent_id_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*persistent_id_.UnsafeRawStringPointer())->clear();
    }
    if (has_reg_id()) {
      GOOGLE_DCHECK(!reg_id_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*reg_id_.UnsafeRawStringPointer())->clear();
    }
    if (has_raw_data()) {
      GOOGLE_DCHECK(!raw_data_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*raw_data_.UnsafeRawStringPointer())->clear();
    }
  }
  if (_has_bits_[8 / 32] & 65280u) {
    ::memset(&stream_id_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&queued_) -
        reinterpret_cast<char*>(&stream_id_)) + sizeof(queued_));
  }
  status_ = GOOGLE_LONGLONG(0);
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool DataMessageStanza::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:mcs_proto.DataMessageStanza)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(16383u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional string id = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(18u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_id()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // required string from = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(26u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_from()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional string to = 4;
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(34u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_to()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // required string category = 5;
      case 5: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(42u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_category()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional string token = 6;
      case 6: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(50u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_token()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated .mcs_proto.AppData app_data = 7;
      case 7: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(58u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_app_data()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool from_trusted_server = 8;
      case 8: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(64u)) {
          set_has_from_trusted_server();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &from_trusted_server_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional string persistent_id = 9;
      case 9: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(74u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_persistent_id()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 stream_id = 10;
      case 10: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(80u)) {
          set_has_stream_id();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &stream_id_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 last_stream_id_received = 11;
      case 11: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(88u)) {
          set_has_last_stream_id_received();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &last_stream_id_received_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional string reg_id = 13;
      case 13: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(106u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_reg_id()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int64 device_user_id = 16;
      case 16: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(128u)) {
          set_has_device_user_id();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &device_user_id_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 ttl = 17;
      case 17: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(136u)) {
          set_has_ttl();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &ttl_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int64 sent = 18;
      case 18: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(144u)) {
          set_has_sent();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &sent_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 queued = 19;
      case 19: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(152u)) {
          set_has_queued();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &queued_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int64 status = 20;
      case 20: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(160u)) {
          set_has_status();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &status_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bytes raw_data = 21;
      case 21: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(170u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_raw_data()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool immediate_ack = 24;
      case 24: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(192u)) {
          set_has_immediate_ack();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &immediate_ack_)));
        } else {
          goto handle_unusual;
        }
        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::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:mcs_proto.DataMessageStanza)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:mcs_proto.DataMessageStanza)
  return false;
#undef DO_
}

void DataMessageStanza::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:mcs_proto.DataMessageStanza)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string id = 2;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      2, this->id(), output);
  }

  // required string from = 3;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      3, this->from(), output);
  }

  // optional string to = 4;
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      4, this->to(), output);
  }

  // required string category = 5;
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      5, this->category(), output);
  }

  // optional string token = 6;
  if (cached_has_bits & 0x00000010u) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      6, this->token(), output);
  }

  // repeated .mcs_proto.AppData app_data = 7;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->app_data_size()); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      7, this->app_data(static_cast<int>(i)), output);
  }

  // optional bool from_trusted_server = 8;
  if (cached_has_bits & 0x00000800u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(8, this->from_trusted_server(), output);
  }

  // optional string persistent_id = 9;
  if (cached_has_bits & 0x00000020u) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      9, this->persistent_id(), output);
  }

  // optional int32 stream_id = 10;
  if (cached_has_bits & 0x00000100u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(10, this->stream_id(), output);
  }

  // optional int32 last_stream_id_received = 11;
  if (cached_has_bits & 0x00000200u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(11, this->last_stream_id_received(), output);
  }

  // optional string reg_id = 13;
  if (cached_has_bits & 0x00000040u) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      13, this->reg_id(), output);
  }

  // optional int64 device_user_id = 16;
  if (cached_has_bits & 0x00000400u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(16, this->device_user_id(), output);
  }

  // optional int32 ttl = 17;
  if (cached_has_bits & 0x00002000u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(17, this->ttl(), output);
  }

  // optional int64 sent = 18;
  if (cached_has_bits & 0x00004000u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(18, this->sent(), output);
  }

  // optional int32 queued = 19;
  if (cached_has_bits & 0x00008000u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(19, this->queued(), output);
  }

  // optional int64 status = 20;
  if (cached_has_bits & 0x00010000u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(20, this->status(), output);
  }

  // optional bytes raw_data = 21;
  if (cached_has_bits & 0x00000080u) {
    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
      21, this->raw_data(), output);
  }

  // optional bool immediate_ack = 24;
  if (cached_has_bits & 0x00001000u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(24, this->immediate_ack(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:mcs_proto.DataMessageStanza)
}

size_t DataMessageStanza::RequiredFieldsByteSizeFallback() const {
// @@protoc_insertion_point(required_fields_byte_size_fallback_start:mcs_proto.DataMessageStanza)
  size_t total_size = 0;

  if (has_from()) {
    // required string from = 3;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::StringSize(
        this->from());
  }

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

  return total_size;
}
size_t DataMessageStanza::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:mcs_proto.DataMessageStanza)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  if (((_has_bits_[0] & 0x0000000a) ^ 0x0000000a) == 0) {  // All required fields are present.
    // required string from = 3;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::StringSize(
        this->from());

    // required string category = 5;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::StringSize(
        this->category());

  } else {
    total_size += RequiredFieldsByteSizeFallback();
  }
  // repeated .mcs_proto.AppData app_data = 7;
  {
    unsigned int count = static_cast<unsigned int>(this->app_data_size());
    total_size += 1UL * count;
    for (unsigned int i = 0; i < count; i++) {
      total_size +=
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->app_data(static_cast<int>(i)));
    }
  }

  // optional string id = 2;
  if (has_id()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::StringSize(
        this->id());
  }

  // optional string to = 4;
  if (has_to()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::StringSize(
        this->to());
  }

  if (_has_bits_[0 / 32] & 240u) {
    // optional string token = 6;
    if (has_token()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->token());
    }

    // optional string persistent_id = 9;
    if (has_persistent_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->persistent_id());
    }

    // optional string reg_id = 13;
    if (has_reg_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->reg_id());
    }

    // optional bytes raw_data = 21;
    if (has_raw_data()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->raw_data());
    }

  }
  if (_has_bits_[8 / 32] & 65280u) {
    // optional int32 stream_id = 10;
    if (has_stream_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->stream_id());
    }

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

    // optional int64 device_user_id = 16;
    if (has_device_user_id()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->device_user_id());
    }

    // optional bool from_trusted_server = 8;
    if (has_from_trusted_server()) {
      total_size += 1 + 1;
    }

    // optional bool immediate_ack = 24;
    if (has_immediate_ack()) {
      total_size += 2 + 1;
    }

    // optional int32 ttl = 17;
    if (has_ttl()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->ttl());
    }

    // optional int64 sent = 18;
    if (has_sent()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->sent());
    }

    // optional int32 queued = 19;
    if (has_queued()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->queued());
    }

  }
  // optional int64 status = 20;
  if (has_status()) {
    total_size += 2 +
      ::google::protobuf::internal::WireFormatLite::Int64Size(
        this->status());
  }

  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

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

void DataMessageStanza::MergeFrom(const DataMessageStanza& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:mcs_proto.DataMessageStanza)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  app_data_.MergeFrom(from.app_data_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 255u) {
    if (cached_has_bits & 0x00000001u) {
      set_has_id();
      id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.id_);
    }
    if (cached_has_bits & 0x00000002u) {
      set_has_from();
      from_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.from_);
    }
    if (cached_has_bits & 0x00000004u) {
      set_has_to();
      to_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.to_);
    }
    if (cached_has_bits & 0x00000008u) {
      set_has_category();
      category_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.category_);
    }
    if (cached_has_bits & 0x00000010u) {
      set_has_token();
      token_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.token_);
    }
    if (cached_has_bits & 0x00000020u) {
      set_has_persistent_id();
      persistent_id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.persistent_id_);
    }
    if (cached_has_bits & 0x00000040u) {
      set_has_reg_id();
      reg_id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.reg_id_);
    }
    if (cached_has_bits & 0x00000080u) {
      set_has_raw_data();
      raw_data_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.raw_data_);
    }
  }
  if (cached_has_bits & 65280u) {
    if (cached_has_bits & 0x00000100u) {
      stream_id_ = from.stream_id_;
    }
    if (cached_has_bits & 0x00000200u) {
      last_stream_id_received_ = from.last_stream_id_received_;
    }
    if (cached_has_bits & 0x00000400u) {
      device_user_id_ = from.device_user_id_;
    }
    if (cached_has_bits & 0x00000800u) {
      from_trusted_server_ = from.from_trusted_server_;
    }
    if (cached_has_bits & 0x00001000u) {
      immediate_ack_ = from.immediate_ack_;
    }
    if (cached_has_bits & 0x00002000u) {
      ttl_ = from.ttl_;
    }
    if (cached_has_bits & 0x00004000u) {
      sent_ = from.sent_;
    }
    if (cached_has_bits & 0x00008000u) {
      queued_ = from.queued_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  if (cached_has_bits & 0x00010000u) {
    set_status(from.status());
  }
}

void DataMessageStanza::CopyFrom(const DataMessageStanza& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:mcs_proto.DataMessageStanza)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool DataMessageStanza::IsInitialized() const {
  if ((_has_bits_[0] & 0x0000000a) != 0x0000000a) return false;
  if (!::google::protobuf::internal::AllAreInitialized(this->app_data())) return false;
  return true;
}

void DataMessageStanza::Swap(DataMessageStanza* other) {
  if (other == this) return;
  InternalSwap(other);
}
void DataMessageStanza::InternalSwap(DataMessageStanza* other) {
  app_data_.InternalSwap(&other->app_data_);
  id_.Swap(&other->id_);
  from_.Swap(&other->from_);
  to_.Swap(&other->to_);
  category_.Swap(&other->category_);
  token_.Swap(&other->token_);
  persistent_id_.Swap(&other->persistent_id_);
  reg_id_.Swap(&other->reg_id_);
  raw_data_.Swap(&other->raw_data_);
  std::swap(stream_id_, other->stream_id_);
  std::swap(last_stream_id_received_, other->last_stream_id_received_);
  std::swap(device_user_id_, other->device_user_id_);
  std::swap(from_trusted_server_, other->from_trusted_server_);
  std::swap(immediate_ack_, other->immediate_ack_);
  std::swap(ttl_, other->ttl_);
  std::swap(sent_, other->sent_);
  std::swap(queued_, other->queued_);
  std::swap(status_, other->status_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string DataMessageStanza::GetTypeName() const {
  return "mcs_proto.DataMessageStanza";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// DataMessageStanza

// optional string id = 2;
bool DataMessageStanza::has_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void DataMessageStanza::set_has_id() {
  _has_bits_[0] |= 0x00000001u;
}
void DataMessageStanza::clear_has_id() {
  _has_bits_[0] &= ~0x00000001u;
}
void DataMessageStanza::clear_id() {
  id_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_id();
}
const ::std::string& DataMessageStanza::id() const {
  // @@protoc_insertion_point(field_get:mcs_proto.DataMessageStanza.id)
  return id_.GetNoArena();
}
void DataMessageStanza::set_id(const ::std::string& value) {
  set_has_id();
  id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:mcs_proto.DataMessageStanza.id)
}
#if LANG_CXX11
void DataMessageStanza::set_id(::std::string&& value) {
  set_has_id();
  id_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:mcs_proto.DataMessageStanza.id)
}
#endif
void DataMessageStanza::set_id(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_id();
  id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:mcs_proto.DataMessageStanza.id)
}
void DataMessageStanza::set_id(const char* value, size_t size) {
  set_has_id();
  id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:mcs_proto.DataMessageStanza.id)
}
::std::string* DataMessageStanza::mutable_id() {
  set_has_id();
  // @@protoc_insertion_point(field_mutable:mcs_proto.DataMessageStanza.id)
  return id_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* DataMessageStanza::release_id() {
  // @@protoc_insertion_point(field_release:mcs_proto.DataMessageStanza.id)
  clear_has_id();
  return id_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void DataMessageStanza::set_allocated_id(::std::string* id) {
  if (id != NULL) {
    set_has_id();
  } else {
    clear_has_id();
  }
  id_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), id);
  // @@protoc_insertion_point(field_set_allocated:mcs_proto.DataMessageStanza.id)
}

// required string from = 3;
bool DataMessageStanza::has_from() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void DataMessageStanza::set_has_from() {
  _has_bits_[0] |= 0x00000002u;
}
void DataMessageStanza::clear_has_from() {
  _has_bits_[0] &= ~0x00000002u;
}
void DataMessageStanza::clear_from() {
  from_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_from();
}
const ::std::string& DataMessageStanza::from() const {
  // @@protoc_insertion_point(field_get:mcs_proto.DataMessageStanza.from)
  return from_.GetNoArena();
}
void DataMessageStanza::set_from(const ::std::string& value) {
  set_has_from();
  from_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:mcs_proto.DataMessageStanza.from)
}
#if LANG_CXX11
void DataMessageStanza::set_from(::std::string&& value) {
  set_has_from();
  from_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:mcs_proto.DataMessageStanza.from)
}
#endif
void DataMessageStanza::set_from(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_from();
  from_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:mcs_proto.DataMessageStanza.from)
}
void DataMessageStanza::set_from(const char* value, size_t size) {
  set_has_from();
  from_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:mcs_proto.DataMessageStanza.from)
}
::std::string* DataMessageStanza::mutable_from() {
  set_has_from();
  // @@protoc_insertion_point(field_mutable:mcs_proto.DataMessageStanza.from)
  return from_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* DataMessageStanza::release_from() {
  // @@protoc_insertion_point(field_release:mcs_proto.DataMessageStanza.from)
  clear_has_from();
  return from_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void DataMessageStanza::set_allocated_from(::std::string* from) {
  if (from != NULL) {
    set_has_from();
  } else {
    clear_has_from();
  }
  from_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from);
  // @@protoc_insertion_point(field_set_allocated:mcs_proto.DataMessageStanza.from)
}

// optional string to = 4;
bool DataMessageStanza::has_to() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
void DataMessageStanza::set_has_to() {
  _has_bits_[0] |= 0x00000004u;
}
void DataMessageStanza::clear_has_to() {
  _has_bits_[0] &= ~0x00000004u;
}
void DataMessageStanza::clear_to() {
  to_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_to();
}
const ::std::string& DataMessageStanza::to() const {
  // @@protoc_insertion_point(field_get:mcs_proto.DataMessageStanza.to)
  return to_.GetNoArena();
}
void DataMessageStanza::set_to(const ::std::string& value) {
  set_has_to();
  to_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:mcs_proto.DataMessageStanza.to)
}
#if LANG_CXX11
void DataMessageStanza::set_to(::std::string&& value) {
  set_has_to();
  to_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:mcs_proto.DataMessageStanza.to)
}
#endif
void DataMessageStanza::set_to(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_to();
  to_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:mcs_proto.DataMessageStanza.to)
}
void DataMessageStanza::set_to(const char* value, size_t size) {
  set_has_to();
  to_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:mcs_proto.DataMessageStanza.to)
}
::std::string* DataMessageStanza::mutable_to() {
  set_has_to();
  // @@protoc_insertion_point(field_mutable:mcs_proto.DataMessageStanza.to)
  return to_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* DataMessageStanza::release_to() {
  // @@protoc_insertion_point(field_release:mcs_proto.DataMessageStanza.to)
  clear_has_to();
  return to_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void DataMessageStanza::set_allocated_to(::std::string* to) {
  if (to != NULL) {
    set_has_to();
  } else {
    clear_has_to();
  }
  to_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), to);
  // @@protoc_insertion_point(field_set_allocated:mcs_proto.DataMessageStanza.to)
}

// required string category = 5;
bool DataMessageStanza::has_category() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
void DataMessageStanza::set_has_category() {
  _has_bits_[0] |= 0x00000008u;
}
void DataMessageStanza::clear_has_category() {
  _has_bits_[0] &= ~0x00000008u;
}
void DataMessageStanza::clear_category() {
  category_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_category();
}
const ::std::string& DataMessageStanza::category() const {
  // @@protoc_insertion_point(field_get:mcs_proto.DataMessageStanza.category)
  return category_.GetNoArena();
}
void DataMessageStanza::set_category(const ::std::string& value) {
  set_has_category();
  category_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:mcs_proto.DataMessageStanza.category)
}
#if LANG_CXX11
void DataMessageStanza::set_category(::std::string&& value) {
  set_has_category();
  category_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:mcs_proto.DataMessageStanza.category)
}
#endif
void DataMessageStanza::set_category(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_category();
  category_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:mcs_proto.DataMessageStanza.category)
}
void DataMessageStanza::set_category(const char* value, size_t size) {
  set_has_category();
  category_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:mcs_proto.DataMessageStanza.category)
}
::std::string* DataMessageStanza::mutable_category() {
  set_has_category();
  // @@protoc_insertion_point(field_mutable:mcs_proto.DataMessageStanza.category)
  return category_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* DataMessageStanza::release_category() {
  // @@protoc_insertion_point(field_release:mcs_proto.DataMessageStanza.category)
  clear_has_category();
  return category_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void DataMessageStanza::set_allocated_category(::std::string* category) {
  if (category != NULL) {
    set_has_category();
  } else {
    clear_has_category();
  }
  category_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), category);
  // @@protoc_insertion_point(field_set_allocated:mcs_proto.DataMessageStanza.category)
}

// optional string token = 6;
bool DataMessageStanza::has_token() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
void DataMessageStanza::set_has_token() {
  _has_bits_[0] |= 0x00000010u;
}
void DataMessageStanza::clear_has_token() {
  _has_bits_[0] &= ~0x00000010u;
}
void DataMessageStanza::clear_token() {
  token_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_token();
}
const ::std::string& DataMessageStanza::token() const {
  // @@protoc_insertion_point(field_get:mcs_proto.DataMessageStanza.token)
  return token_.GetNoArena();
}
void DataMessageStanza::set_token(const ::std::string& value) {
  set_has_token();
  token_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:mcs_proto.DataMessageStanza.token)
}
#if LANG_CXX11
void DataMessageStanza::set_token(::std::string&& value) {
  set_has_token();
  token_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:mcs_proto.DataMessageStanza.token)
}
#endif
void DataMessageStanza::set_token(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_token();
  token_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:mcs_proto.DataMessageStanza.token)
}
void DataMessageStanza::set_token(const char* value, size_t size) {
  set_has_token();
  token_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:mcs_proto.DataMessageStanza.token)
}
::std::string* DataMessageStanza::mutable_token() {
  set_has_token();
  // @@protoc_insertion_point(field_mutable:mcs_proto.DataMessageStanza.token)
  return token_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* DataMessageStanza::release_token() {
  // @@protoc_insertion_point(field_release:mcs_proto.DataMessageStanza.token)
  clear_has_token();
  return token_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void DataMessageStanza::set_allocated_token(::std::string* token) {
  if (token != NULL) {
    set_has_token();
  } else {
    clear_has_token();
  }
  token_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), token);
  // @@protoc_insertion_point(field_set_allocated:mcs_proto.DataMessageStanza.token)
}

// repeated .mcs_proto.AppData app_data = 7;
int DataMessageStanza::app_data_size() const {
  return app_data_.size();
}
void DataMessageStanza::clear_app_data() {
  app_data_.Clear();
}
const ::mcs_proto::AppData& DataMessageStanza::app_data(int index) const {
  // @@protoc_insertion_point(field_get:mcs_proto.DataMessageStanza.app_data)
  return app_data_.Get(index);
}
::mcs_proto::AppData* DataMessageStanza::mutable_app_data(int index) {
  // @@protoc_insertion_point(field_mutable:mcs_proto.DataMessageStanza.app_data)
  return app_data_.Mutable(index);
}
::mcs_proto::AppData* DataMessageStanza::add_app_data() {
  // @@protoc_insertion_point(field_add:mcs_proto.DataMessageStanza.app_data)
  return app_data_.Add();
}
::google::protobuf::RepeatedPtrField< ::mcs_proto::AppData >*
DataMessageStanza::mutable_app_data() {
  // @@protoc_insertion_point(field_mutable_list:mcs_proto.DataMessageStanza.app_data)
  return &app_data_;
}
const ::google::protobuf::RepeatedPtrField< ::mcs_proto::AppData >&
DataMessageStanza::app_data() const {
  // @@protoc_insertion_point(field_list:mcs_proto.DataMessageStanza.app_data)
  return app_data_;
}

// optional bool from_trusted_server = 8;
bool DataMessageStanza::has_from_trusted_server() const {
  return (_has_bits_[0] & 0x00000800u) != 0;
}
void DataMessageStanza::set_has_from_trusted_server() {
  _has_bits_[0] |= 0x00000800u;
}
void DataMessageStanza::clear_has_from_trusted_server() {
  _has_bits_[0] &= ~0x00000800u;
}
void DataMessageStanza::clear_from_trusted_server() {
  from_trusted_server_ = false;
  clear_has_from_trusted_server();
}
bool DataMessageStanza::from_trusted_server() const {
  // @@protoc_insertion_point(field_get:mcs_proto.DataMessageStanza.from_trusted_server)
  return from_trusted_server_;
}
void DataMessageStanza::set_from_trusted_server(bool value) {
  set_has_from_trusted_server();
  from_trusted_server_ = value;
  // @@protoc_insertion_point(field_set:mcs_proto.DataMessageStanza.from_trusted_server)
}

// optional string persistent_id = 9;
bool DataMessageStanza::has_persistent_id() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
void DataMessageStanza::set_has_persistent_id() {
  _has_bits_[0] |= 0x00000020u;
}
void DataMessageStanza::clear_has_persistent_id() {
  _has_bits_[0] &= ~0x00000020u;
}
void DataMessageStanza::clear_persistent_id() {
  persistent_id_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_persistent_id();
}
const ::std::string& DataMessageStanza::persistent_id() const {
  // @@protoc_insertion_point(field_get:mcs_proto.DataMessageStanza.persistent_id)
  return persistent_id_.GetNoArena();
}
void DataMessageStanza::set_persistent_id(const ::std::string& value) {
  set_has_persistent_id();
  persistent_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:mcs_proto.DataMessageStanza.persistent_id)
}
#if LANG_CXX11
void DataMessageStanza::set_persistent_id(::std::string&& value) {
  set_has_persistent_id();
  persistent_id_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:mcs_proto.DataMessageStanza.persistent_id)
}
#endif
void DataMessageStanza::set_persistent_id(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_persistent_id();
  persistent_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:mcs_proto.DataMessageStanza.persistent_id)
}
void DataMessageStanza::set_persistent_id(const char* value, size_t size) {
  set_has_persistent_id();
  persistent_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:mcs_proto.DataMessageStanza.persistent_id)
}
::std::string* DataMessageStanza::mutable_persistent_id() {
  set_has_persistent_id();
  // @@protoc_insertion_point(field_mutable:mcs_proto.DataMessageStanza.persistent_id)
  return persistent_id_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* DataMessageStanza::release_persistent_id() {
  // @@protoc_insertion_point(field_release:mcs_proto.DataMessageStanza.persistent_id)
  clear_has_persistent_id();
  return persistent_id_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void DataMessageStanza::set_allocated_persistent_id(::std::string* persistent_id) {
  if (persistent_id != NULL) {
    set_has_persistent_id();
  } else {
    clear_has_persistent_id();
  }
  persistent_id_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), persistent_id);
  // @@protoc_insertion_point(field_set_allocated:mcs_proto.DataMessageStanza.persistent_id)
}

// optional int32 stream_id = 10;
bool DataMessageStanza::has_stream_id() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
void DataMessageStanza::set_has_stream_id() {
  _has_bits_[0] |= 0x00000100u;
}
void DataMessageStanza::clear_has_stream_id() {
  _has_bits_[0] &= ~0x00000100u;
}
void DataMessageStanza::clear_stream_id() {
  stream_id_ = 0;
  clear_has_stream_id();
}
::google::protobuf::int32 DataMessageStanza::stream_id() const {
  // @@protoc_insertion_point(field_get:mcs_proto.DataMessageStanza.stream_id)
  return stream_id_;
}
void DataMessageStanza::set_stream_id(::google::protobuf::int32 value) {
  set_has_stream_id();
  stream_id_ = value;
  // @@protoc_insertion_point(field_set:mcs_proto.DataMessageStanza.stream_id)
}

// optional int32 last_stream_id_received = 11;
bool DataMessageStanza::has_last_stream_id_received() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
void DataMessageStanza::set_has_last_stream_id_received() {
  _has_bits_[0] |= 0x00000200u;
}
void DataMessageStanza::clear_has_last_stream_id_received() {
  _has_bits_[0] &= ~0x00000200u;
}
void DataMessageStanza::clear_last_stream_id_received() {
  last_stream_id_received_ = 0;
  clear_has_last_stream_id_received();
}
::google::protobuf::int32 DataMessageStanza::last_stream_id_received() const {
  // @@protoc_insertion_point(field_get:mcs_proto.DataMessageStanza.last_stream_id_received)
  return last_stream_id_received_;
}
void DataMessageStanza::set_last_stream_id_received(::google::protobuf::int32 value) {
  set_has_last_stream_id_received();
  last_stream_id_received_ = value;
  // @@protoc_insertion_point(field_set:mcs_proto.DataMessageStanza.last_stream_id_received)
}

// optional string reg_id = 13;
bool DataMessageStanza::has_reg_id() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
void DataMessageStanza::set_has_reg_id() {
  _has_bits_[0] |= 0x00000040u;
}
void DataMessageStanza::clear_has_reg_id() {
  _has_bits_[0] &= ~0x00000040u;
}
void DataMessageStanza::clear_reg_id() {
  reg_id_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_reg_id();
}
const ::std::string& DataMessageStanza::reg_id() const {
  // @@protoc_insertion_point(field_get:mcs_proto.DataMessageStanza.reg_id)
  return reg_id_.GetNoArena();
}
void DataMessageStanza::set_reg_id(const ::std::string& value) {
  set_has_reg_id();
  reg_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:mcs_proto.DataMessageStanza.reg_id)
}
#if LANG_CXX11
void DataMessageStanza::set_reg_id(::std::string&& value) {
  set_has_reg_id();
  reg_id_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:mcs_proto.DataMessageStanza.reg_id)
}
#endif
void DataMessageStanza::set_reg_id(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_reg_id();
  reg_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:mcs_proto.DataMessageStanza.reg_id)
}
void DataMessageStanza::set_reg_id(const char* value, size_t size) {
  set_has_reg_id();
  reg_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:mcs_proto.DataMessageStanza.reg_id)
}
::std::string* DataMessageStanza::mutable_reg_id() {
  set_has_reg_id();
  // @@protoc_insertion_point(field_mutable:mcs_proto.DataMessageStanza.reg_id)
  return reg_id_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* DataMessageStanza::release_reg_id() {
  // @@protoc_insertion_point(field_release:mcs_proto.DataMessageStanza.reg_id)
  clear_has_reg_id();
  return reg_id_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void DataMessageStanza::set_allocated_reg_id(::std::string* reg_id) {
  if (reg_id != NULL) {
    set_has_reg_id();
  } else {
    clear_has_reg_id();
  }
  reg_id_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), reg_id);
  // @@protoc_insertion_point(field_set_allocated:mcs_proto.DataMessageStanza.reg_id)
}

// optional int64 device_user_id = 16;
bool DataMessageStanza::has_device_user_id() const {
  return (_has_bits_[0] & 0x00000400u) != 0;
}
void DataMessageStanza::set_has_device_user_id() {
  _has_bits_[0] |= 0x00000400u;
}
void DataMessageStanza::clear_has_device_user_id() {
  _has_bits_[0] &= ~0x00000400u;
}
void DataMessageStanza::clear_device_user_id() {
  device_user_id_ = GOOGLE_LONGLONG(0);
  clear_has_device_user_id();
}
::google::protobuf::int64 DataMessageStanza::device_user_id() const {
  // @@protoc_insertion_point(field_get:mcs_proto.DataMessageStanza.device_user_id)
  return device_user_id_;
}
void DataMessageStanza::set_device_user_id(::google::protobuf::int64 value) {
  set_has_device_user_id();
  device_user_id_ = value;
  // @@protoc_insertion_point(field_set:mcs_proto.DataMessageStanza.device_user_id)
}

// optional int32 ttl = 17;
bool DataMessageStanza::has_ttl() const {
  return (_has_bits_[0] & 0x00002000u) != 0;
}
void DataMessageStanza::set_has_ttl() {
  _has_bits_[0] |= 0x00002000u;
}
void DataMessageStanza::clear_has_ttl() {
  _has_bits_[0] &= ~0x00002000u;
}
void DataMessageStanza::clear_ttl() {
  ttl_ = 0;
  clear_has_ttl();
}
::google::protobuf::int32 DataMessageStanza::ttl() const {
  // @@protoc_insertion_point(field_get:mcs_proto.DataMessageStanza.ttl)
  return ttl_;
}
void DataMessageStanza::set_ttl(::google::protobuf::int32 value) {
  set_has_ttl();
  ttl_ = value;
  // @@protoc_insertion_point(field_set:mcs_proto.DataMessageStanza.ttl)
}

// optional int64 sent = 18;
bool DataMessageStanza::has_sent() const {
  return (_has_bits_[0] & 0x00004000u) != 0;
}
void DataMessageStanza::set_has_sent() {
  _has_bits_[0] |= 0x00004000u;
}
void DataMessageStanza::clear_has_sent() {
  _has_bits_[0] &= ~0x00004000u;
}
void DataMessageStanza::clear_sent() {
  sent_ = GOOGLE_LONGLONG(0);
  clear_has_sent();
}
::google::protobuf::int64 DataMessageStanza::sent() const {
  // @@protoc_insertion_point(field_get:mcs_proto.DataMessageStanza.sent)
  return sent_;
}
void DataMessageStanza::set_sent(::google::protobuf::int64 value) {
  set_has_sent();
  sent_ = value;
  // @@protoc_insertion_point(field_set:mcs_proto.DataMessageStanza.sent)
}

// optional int32 queued = 19;
bool DataMessageStanza::has_queued() const {
  return (_has_bits_[0] & 0x00008000u) != 0;
}
void DataMessageStanza::set_has_queued() {
  _has_bits_[0] |= 0x00008000u;
}
void DataMessageStanza::clear_has_queued() {
  _has_bits_[0] &= ~0x00008000u;
}
void DataMessageStanza::clear_queued() {
  queued_ = 0;
  clear_has_queued();
}
::google::protobuf::int32 DataMessageStanza::queued() const {
  // @@protoc_insertion_point(field_get:mcs_proto.DataMessageStanza.queued)
  return queued_;
}
void DataMessageStanza::set_queued(::google::protobuf::int32 value) {
  set_has_queued();
  queued_ = value;
  // @@protoc_insertion_point(field_set:mcs_proto.DataMessageStanza.queued)
}

// optional int64 status = 20;
bool DataMessageStanza::has_status() const {
  return (_has_bits_[0] & 0x00010000u) != 0;
}
void DataMessageStanza::set_has_status() {
  _has_bits_[0] |= 0x00010000u;
}
void DataMessageStanza::clear_has_status() {
  _has_bits_[0] &= ~0x00010000u;
}
void DataMessageStanza::clear_status() {
  status_ = GOOGLE_LONGLONG(0);
  clear_has_status();
}
::google::protobuf::int64 DataMessageStanza::status() const {
  // @@protoc_insertion_point(field_get:mcs_proto.DataMessageStanza.status)
  return status_;
}
void DataMessageStanza::set_status(::google::protobuf::int64 value) {
  set_has_status();
  status_ = value;
  // @@protoc_insertion_point(field_set:mcs_proto.DataMessageStanza.status)
}

// optional bytes raw_data = 21;
bool DataMessageStanza::has_raw_data() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
void DataMessageStanza::set_has_raw_data() {
  _has_bits_[0] |= 0x00000080u;
}
void DataMessageStanza::clear_has_raw_data() {
  _has_bits_[0] &= ~0x00000080u;
}
void DataMessageStanza::clear_raw_data() {
  raw_data_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_raw_data();
}
const ::std::string& DataMessageStanza::raw_data() const {
  // @@protoc_insertion_point(field_get:mcs_proto.DataMessageStanza.raw_data)
  return raw_data_.GetNoArena();
}
void DataMessageStanza::set_raw_data(const ::std::string& value) {
  set_has_raw_data();
  raw_data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:mcs_proto.DataMessageStanza.raw_data)
}
#if LANG_CXX11
void DataMessageStanza::set_raw_data(::std::string&& value) {
  set_has_raw_data();
  raw_data_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:mcs_proto.DataMessageStanza.raw_data)
}
#endif
void DataMessageStanza::set_raw_data(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_raw_data();
  raw_data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:mcs_proto.DataMessageStanza.raw_data)
}
void DataMessageStanza::set_raw_data(const void* value, size_t size) {
  set_has_raw_data();
  raw_data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:mcs_proto.DataMessageStanza.raw_data)
}
::std::string* DataMessageStanza::mutable_raw_data() {
  set_has_raw_data();
  // @@protoc_insertion_point(field_mutable:mcs_proto.DataMessageStanza.raw_data)
  return raw_data_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* DataMessageStanza::release_raw_data() {
  // @@protoc_insertion_point(field_release:mcs_proto.DataMessageStanza.raw_data)
  clear_has_raw_data();
  return raw_data_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void DataMessageStanza::set_allocated_raw_data(::std::string* raw_data) {
  if (raw_data != NULL) {
    set_has_raw_data();
  } else {
    clear_has_raw_data();
  }
  raw_data_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), raw_data);
  // @@protoc_insertion_point(field_set_allocated:mcs_proto.DataMessageStanza.raw_data)
}

// optional bool immediate_ack = 24;
bool DataMessageStanza::has_immediate_ack() const {
  return (_has_bits_[0] & 0x00001000u) != 0;
}
void DataMessageStanza::set_has_immediate_ack() {
  _has_bits_[0] |= 0x00001000u;
}
void DataMessageStanza::clear_has_immediate_ack() {
  _has_bits_[0] &= ~0x00001000u;
}
void DataMessageStanza::clear_immediate_ack() {
  immediate_ack_ = false;
  clear_has_immediate_ack();
}
bool DataMessageStanza::immediate_ack() const {
  // @@protoc_insertion_point(field_get:mcs_proto.DataMessageStanza.immediate_ack)
  return immediate_ack_;
}
void DataMessageStanza::set_immediate_ack(bool value) {
  set_has_immediate_ack();
  immediate_ack_ = value;
  // @@protoc_insertion_point(field_set:mcs_proto.DataMessageStanza.immediate_ack)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

StreamAck::StreamAck()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_mcs_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:mcs_proto.StreamAck)
}
StreamAck::StreamAck(const StreamAck& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:mcs_proto.StreamAck)
}

void StreamAck::SharedCtor() {
  _cached_size_ = 0;
}

StreamAck::~StreamAck() {
  // @@protoc_insertion_point(destructor:mcs_proto.StreamAck)
  SharedDtor();
}

void StreamAck::SharedDtor() {
}

void StreamAck::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const StreamAck& StreamAck::default_instance() {
  protobuf_mcs_2eproto::InitDefaults();
  return *internal_default_instance();
}

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

void StreamAck::Clear() {
// @@protoc_insertion_point(message_clear_start:mcs_proto.StreamAck)
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool StreamAck::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:mcs_proto.StreamAck)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
  handle_unusual:
    if (tag == 0 ||
        ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
        ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
      goto success;
    }
    DO_(::google::protobuf::internal::WireFormatLite::SkipField(
        input, tag, &unknown_fields_stream));
  }
success:
  // @@protoc_insertion_point(parse_success:mcs_proto.StreamAck)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:mcs_proto.StreamAck)
  return false;
#undef DO_
}

void StreamAck::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:mcs_proto.StreamAck)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:mcs_proto.StreamAck)
}

size_t StreamAck::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:mcs_proto.StreamAck)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

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

void StreamAck::MergeFrom(const StreamAck& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:mcs_proto.StreamAck)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

}

void StreamAck::CopyFrom(const StreamAck& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:mcs_proto.StreamAck)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool StreamAck::IsInitialized() const {
  return true;
}

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

::std::string StreamAck::GetTypeName() const {
  return "mcs_proto.StreamAck";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// StreamAck

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int SelectiveAck::kIdFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

SelectiveAck::SelectiveAck()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_mcs_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:mcs_proto.SelectiveAck)
}
SelectiveAck::SelectiveAck(const SelectiveAck& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0),
      id_(from.id_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:mcs_proto.SelectiveAck)
}

void SelectiveAck::SharedCtor() {
  _cached_size_ = 0;
}

SelectiveAck::~SelectiveAck() {
  // @@protoc_insertion_point(destructor:mcs_proto.SelectiveAck)
  SharedDtor();
}

void SelectiveAck::SharedDtor() {
}

void SelectiveAck::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const SelectiveAck& SelectiveAck::default_instance() {
  protobuf_mcs_2eproto::InitDefaults();
  return *internal_default_instance();
}

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

void SelectiveAck::Clear() {
// @@protoc_insertion_point(message_clear_start:mcs_proto.SelectiveAck)
  id_.Clear();
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool SelectiveAck::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:mcs_proto.SelectiveAck)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // repeated string id = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->add_id()));
        } else {
          goto handle_unusual;
        }
        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::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:mcs_proto.SelectiveAck)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:mcs_proto.SelectiveAck)
  return false;
#undef DO_
}

void SelectiveAck::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:mcs_proto.SelectiveAck)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated string id = 1;
  for (int i = 0, n = this->id_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteString(
      1, this->id(i), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:mcs_proto.SelectiveAck)
}

size_t SelectiveAck::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:mcs_proto.SelectiveAck)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  // repeated string id = 1;
  total_size += 1 *
      ::google::protobuf::internal::FromIntSize(this->id_size());
  for (int i = 0, n = this->id_size(); i < n; i++) {
    total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
      this->id(i));
  }

  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

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

void SelectiveAck::MergeFrom(const SelectiveAck& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:mcs_proto.SelectiveAck)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  id_.MergeFrom(from.id_);
}

void SelectiveAck::CopyFrom(const SelectiveAck& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:mcs_proto.SelectiveAck)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool SelectiveAck::IsInitialized() const {
  return true;
}

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

::std::string SelectiveAck::GetTypeName() const {
  return "mcs_proto.SelectiveAck";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// SelectiveAck

// repeated string id = 1;
int SelectiveAck::id_size() const {
  return id_.size();
}
void SelectiveAck::clear_id() {
  id_.Clear();
}
const ::std::string& SelectiveAck::id(int index) const {
  // @@protoc_insertion_point(field_get:mcs_proto.SelectiveAck.id)
  return id_.Get(index);
}
::std::string* SelectiveAck::mutable_id(int index) {
  // @@protoc_insertion_point(field_mutable:mcs_proto.SelectiveAck.id)
  return id_.Mutable(index);
}
void SelectiveAck::set_id(int index, const ::std::string& value) {
  // @@protoc_insertion_point(field_set:mcs_proto.SelectiveAck.id)
  id_.Mutable(index)->assign(value);
}
#if LANG_CXX11
void SelectiveAck::set_id(int index, ::std::string&& value) {
  // @@protoc_insertion_point(field_set:mcs_proto.SelectiveAck.id)
  id_.Mutable(index)->assign(std::move(value));
}
#endif
void SelectiveAck::set_id(int index, const char* value) {
  GOOGLE_DCHECK(value != NULL);
  id_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:mcs_proto.SelectiveAck.id)
}
void SelectiveAck::set_id(int index, const char* value, size_t size) {
  id_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:mcs_proto.SelectiveAck.id)
}
::std::string* SelectiveAck::add_id() {
  // @@protoc_insertion_point(field_add_mutable:mcs_proto.SelectiveAck.id)
  return id_.Add();
}
void SelectiveAck::add_id(const ::std::string& value) {
  id_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:mcs_proto.SelectiveAck.id)
}
#if LANG_CXX11
void SelectiveAck::add_id(::std::string&& value) {
  id_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:mcs_proto.SelectiveAck.id)
}
#endif
void SelectiveAck::add_id(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  id_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:mcs_proto.SelectiveAck.id)
}
void SelectiveAck::add_id(const char* value, size_t size) {
  id_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:mcs_proto.SelectiveAck.id)
}
const ::google::protobuf::RepeatedPtrField< ::std::string>&
SelectiveAck::id() const {
  // @@protoc_insertion_point(field_list:mcs_proto.SelectiveAck.id)
  return id_;
}
::google::protobuf::RepeatedPtrField< ::std::string>*
SelectiveAck::mutable_id() {
  // @@protoc_insertion_point(field_mutable_list:mcs_proto.SelectiveAck.id)
  return &id_;
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

// @@protoc_insertion_point(namespace_scope)

}  // namespace mcs_proto

// @@protoc_insertion_point(global_scope)