text:
#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
#include "IM.Login.pb.h"

#include <algorithm>

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

namespace IM {
namespace Login {

void protobuf_ShutdownFile_IM_2eLogin_2eproto() {
  delete IMMsgServReq::default_instance_;
  delete IMMsgServRsp::default_instance_;
  delete IMLoginReq::default_instance_;
  delete IMLoginRes::default_instance_;
  delete IMLogoutReq::default_instance_;
  delete IMLogoutRsp::default_instance_;
  delete IMKickUser::default_instance_;
  delete IMDeviceTokenReq::default_instance_;
  delete IMDeviceTokenRsp::default_instance_;
  delete IMKickPCClientReq::default_instance_;
  delete IMKickPCClientRsp::default_instance_;
  delete IMPushShieldReq::default_instance_;
  delete IMPushShieldRsp::default_instance_;
  delete IMQueryPushShieldReq::default_instance_;
  delete IMQueryPushShieldRsp::default_instance_;
}

#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
void protobuf_AddDesc_IM_2eLogin_2eproto_impl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

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

#endif
  ::IM::BaseDefine::protobuf_AddDesc_IM_2eBaseDefine_2eproto();
  IMMsgServReq::default_instance_ = new IMMsgServReq();
  IMMsgServRsp::default_instance_ = new IMMsgServRsp();
  IMLoginReq::default_instance_ = new IMLoginReq();
  IMLoginRes::default_instance_ = new IMLoginRes();
  IMLogoutReq::default_instance_ = new IMLogoutReq();
  IMLogoutRsp::default_instance_ = new IMLogoutRsp();
  IMKickUser::default_instance_ = new IMKickUser();
  IMDeviceTokenReq::default_instance_ = new IMDeviceTokenReq();
  IMDeviceTokenRsp::default_instance_ = new IMDeviceTokenRsp();
  IMKickPCClientReq::default_instance_ = new IMKickPCClientReq();
  IMKickPCClientRsp::default_instance_ = new IMKickPCClientRsp();
  IMPushShieldReq::default_instance_ = new IMPushShieldReq();
  IMPushShieldRsp::default_instance_ = new IMPushShieldRsp();
  IMQueryPushShieldReq::default_instance_ = new IMQueryPushShieldReq();
  IMQueryPushShieldRsp::default_instance_ = new IMQueryPushShieldRsp();
  IMMsgServReq::default_instance_->InitAsDefaultInstance();
  IMMsgServRsp::default_instance_->InitAsDefaultInstance();
  IMLoginReq::default_instance_->InitAsDefaultInstance();
  IMLoginRes::default_instance_->InitAsDefaultInstance();
  IMLogoutReq::default_instance_->InitAsDefaultInstance();
  IMLogoutRsp::default_instance_->InitAsDefaultInstance();
  IMKickUser::default_instance_->InitAsDefaultInstance();
  IMDeviceTokenReq::default_instance_->InitAsDefaultInstance();
  IMDeviceTokenRsp::default_instance_->InitAsDefaultInstance();
  IMKickPCClientReq::default_instance_->InitAsDefaultInstance();
  IMKickPCClientRsp::default_instance_->InitAsDefaultInstance();
  IMPushShieldReq::default_instance_->InitAsDefaultInstance();
  IMPushShieldRsp::default_instance_->InitAsDefaultInstance();
  IMQueryPushShieldReq::default_instance_->InitAsDefaultInstance();
  IMQueryPushShieldRsp::default_instance_->InitAsDefaultInstance();
  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_IM_2eLogin_2eproto);
}

#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AddDesc_IM_2eLogin_2eproto_once_);
void protobuf_AddDesc_IM_2eLogin_2eproto() {
  ::google::protobuf::GoogleOnceInit(&protobuf_AddDesc_IM_2eLogin_2eproto_once_,
                 &protobuf_AddDesc_IM_2eLogin_2eproto_impl);
}
#else
// Force AddDescriptors() to be called at static initialization time.
struct StaticDescriptorInitializer_IM_2eLogin_2eproto {
  StaticDescriptorInitializer_IM_2eLogin_2eproto() {
    protobuf_AddDesc_IM_2eLogin_2eproto();
  }
} static_descriptor_initializer_IM_2eLogin_2eproto_;
#endif

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

#ifndef _MSC_VER
#endif  // !_MSC_VER

IMMsgServReq::IMMsgServReq()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:IM.Login.IMMsgServReq)
}

void IMMsgServReq::InitAsDefaultInstance() {
}

IMMsgServReq::IMMsgServReq(const IMMsgServReq& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:IM.Login.IMMsgServReq)
}

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

IMMsgServReq::~IMMsgServReq() {
  // @@protoc_insertion_point(destructor:IM.Login.IMMsgServReq)
  SharedDtor();
}

void IMMsgServReq::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

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

IMMsgServReq* IMMsgServReq::default_instance_ = NULL;

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

void IMMsgServReq::Clear() {
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool IMMsgServReq::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:IM.Login.IMMsgServReq)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    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:IM.Login.IMMsgServReq)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:IM.Login.IMMsgServReq)
  return false;
#undef DO_
}

void IMMsgServReq::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:IM.Login.IMMsgServReq)
  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:IM.Login.IMMsgServReq)
}

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

  total_size += unknown_fields().size();

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

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

void IMMsgServReq::MergeFrom(const IMMsgServReq& from) {
  GOOGLE_CHECK_NE(&from, this);
  mutable_unknown_fields()->append(from.unknown_fields());
}

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

bool IMMsgServReq::IsInitialized() const {

  return true;
}

void IMMsgServReq::Swap(IMMsgServReq* other) {
  if (other != this) {
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string IMMsgServReq::GetTypeName() const {
  return "IM.Login.IMMsgServReq";
}

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

#ifndef _MSC_VER
const int IMMsgServRsp::kResultCodeFieldNumber;
const int IMMsgServRsp::kPriorIpFieldNumber;
const int IMMsgServRsp::kBackipIpFieldNumber;
const int IMMsgServRsp::kPortFieldNumber;
#endif  // !_MSC_VER

IMMsgServRsp::IMMsgServRsp()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:IM.Login.IMMsgServRsp)
}

void IMMsgServRsp::InitAsDefaultInstance() {
}

IMMsgServRsp::IMMsgServRsp(const IMMsgServRsp& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:IM.Login.IMMsgServRsp)
}

void IMMsgServRsp::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  result_code_ = 0;
  prior_ip_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  backip_ip_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  port_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

IMMsgServRsp::~IMMsgServRsp() {
  // @@protoc_insertion_point(destructor:IM.Login.IMMsgServRsp)
  SharedDtor();
}

void IMMsgServRsp::SharedDtor() {
  if (prior_ip_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete prior_ip_;
  }
  if (backip_ip_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete backip_ip_;
  }
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

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

IMMsgServRsp* IMMsgServRsp::default_instance_ = NULL;

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

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

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  if (_has_bits_[0 / 32] & 15) {
    ZR_(result_code_, port_);
    if (has_prior_ip()) {
      if (prior_ip_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        prior_ip_->clear();
      }
    }
    if (has_backip_ip()) {
      if (backip_ip_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        backip_ip_->clear();
      }
    }
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool IMMsgServRsp::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:IM.Login.IMMsgServRsp)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required .IM.BaseDefine.ResultType result_code = 1;
      case 1: {
        if (tag == 8) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::IM::BaseDefine::ResultType_IsValid(value)) {
            set_result_code(static_cast< ::IM::BaseDefine::ResultType >(value));
          } else {
            unknown_fields_stream.WriteVarint32(tag);
            unknown_fields_stream.WriteVarint32(value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_prior_ip;
        break;
      }

      // optional string prior_ip = 2;
      case 2: {
        if (tag == 18) {
         parse_prior_ip:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_prior_ip()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_backip_ip;
        break;
      }

      // optional string backip_ip = 3;
      case 3: {
        if (tag == 26) {
         parse_backip_ip:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_backip_ip()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(32)) goto parse_port;
        break;
      }

      // optional uint32 port = 4;
      case 4: {
        if (tag == 32) {
         parse_port:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &port_)));
          set_has_port();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:IM.Login.IMMsgServRsp)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:IM.Login.IMMsgServRsp)
  return false;
#undef DO_
}

void IMMsgServRsp::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:IM.Login.IMMsgServRsp)
  // required .IM.BaseDefine.ResultType result_code = 1;
  if (has_result_code()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->result_code(), output);
  }

  // optional string prior_ip = 2;
  if (has_prior_ip()) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      2, this->prior_ip(), output);
  }

  // optional string backip_ip = 3;
  if (has_backip_ip()) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      3, this->backip_ip(), output);
  }

  // optional uint32 port = 4;
  if (has_port()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->port(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:IM.Login.IMMsgServRsp)
}

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required .IM.BaseDefine.ResultType result_code = 1;
    if (has_result_code()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->result_code());
    }

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

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

    // optional uint32 port = 4;
    if (has_port()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->port());
    }

  }
  total_size += unknown_fields().size();

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

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

void IMMsgServRsp::MergeFrom(const IMMsgServRsp& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_result_code()) {
      set_result_code(from.result_code());
    }
    if (from.has_prior_ip()) {
      set_prior_ip(from.prior_ip());
    }
    if (from.has_backip_ip()) {
      set_backip_ip(from.backip_ip());
    }
    if (from.has_port()) {
      set_port(from.port());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

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

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

  return true;
}

void IMMsgServRsp::Swap(IMMsgServRsp* other) {
  if (other != this) {
    std::swap(result_code_, other->result_code_);
    std::swap(prior_ip_, other->prior_ip_);
    std::swap(backip_ip_, other->backip_ip_);
    std::swap(port_, other->port_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string IMMsgServRsp::GetTypeName() const {
  return "IM.Login.IMMsgServRsp";
}

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

#ifndef _MSC_VER
const int IMLoginReq::kUserNameFieldNumber;
const int IMLoginReq::kPasswordFieldNumber;
const int IMLoginReq::kOnlineStatusFieldNumber;
const int IMLoginReq::kClientTypeFieldNumber;
const int IMLoginReq::kClientVersionFieldNumber;
#endif  // !_MSC_VER

IMLoginReq::IMLoginReq()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:IM.Login.IMLoginReq)
}

void IMLoginReq::InitAsDefaultInstance() {
}

IMLoginReq::IMLoginReq(const IMLoginReq& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:IM.Login.IMLoginReq)
}

void IMLoginReq::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  user_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  password_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  online_status_ = 1;
  client_type_ = 1;
  client_version_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

IMLoginReq::~IMLoginReq() {
  // @@protoc_insertion_point(destructor:IM.Login.IMLoginReq)
  SharedDtor();
}

void IMLoginReq::SharedDtor() {
  if (user_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete user_name_;
  }
  if (password_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete password_;
  }
  if (client_version_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete client_version_;
  }
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

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

IMLoginReq* IMLoginReq::default_instance_ = NULL;

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

void IMLoginReq::Clear() {
  if (_has_bits_[0 / 32] & 31) {
    if (has_user_name()) {
      if (user_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        user_name_->clear();
      }
    }
    if (has_password()) {
      if (password_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        password_->clear();
      }
    }
    online_status_ = 1;
    client_type_ = 1;
    if (has_client_version()) {
      if (client_version_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        client_version_->clear();
      }
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool IMLoginReq::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:IM.Login.IMLoginReq)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required string user_name = 1;
      case 1: {
        if (tag == 10) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_user_name()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_password;
        break;
      }

      // required string password = 2;
      case 2: {
        if (tag == 18) {
         parse_password:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_password()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_online_status;
        break;
      }

      // required .IM.BaseDefine.UserStatType online_status = 3;
      case 3: {
        if (tag == 24) {
         parse_online_status:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::IM::BaseDefine::UserStatType_IsValid(value)) {
            set_online_status(static_cast< ::IM::BaseDefine::UserStatType >(value));
          } else {
            unknown_fields_stream.WriteVarint32(tag);
            unknown_fields_stream.WriteVarint32(value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(32)) goto parse_client_type;
        break;
      }

      // required .IM.BaseDefine.ClientType client_type = 4;
      case 4: {
        if (tag == 32) {
         parse_client_type:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::IM::BaseDefine::ClientType_IsValid(value)) {
            set_client_type(static_cast< ::IM::BaseDefine::ClientType >(value));
          } else {
            unknown_fields_stream.WriteVarint32(tag);
            unknown_fields_stream.WriteVarint32(value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(42)) goto parse_client_version;
        break;
      }

      // optional string client_version = 5;
      case 5: {
        if (tag == 42) {
         parse_client_version:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_client_version()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:IM.Login.IMLoginReq)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:IM.Login.IMLoginReq)
  return false;
#undef DO_
}

void IMLoginReq::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:IM.Login.IMLoginReq)
  // required string user_name = 1;
  if (has_user_name()) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->user_name(), output);
  }

  // required string password = 2;
  if (has_password()) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      2, this->password(), output);
  }

  // required .IM.BaseDefine.UserStatType online_status = 3;
  if (has_online_status()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      3, this->online_status(), output);
  }

  // required .IM.BaseDefine.ClientType client_type = 4;
  if (has_client_type()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      4, this->client_type(), output);
  }

  // optional string client_version = 5;
  if (has_client_version()) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      5, this->client_version(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:IM.Login.IMLoginReq)
}

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required string user_name = 1;
    if (has_user_name()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->user_name());
    }

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

    // required .IM.BaseDefine.UserStatType online_status = 3;
    if (has_online_status()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->online_status());
    }

    // required .IM.BaseDefine.ClientType client_type = 4;
    if (has_client_type()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->client_type());
    }

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

  }
  total_size += unknown_fields().size();

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

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

void IMLoginReq::MergeFrom(const IMLoginReq& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_user_name()) {
      set_user_name(from.user_name());
    }
    if (from.has_password()) {
      set_password(from.password());
    }
    if (from.has_online_status()) {
      set_online_status(from.online_status());
    }
    if (from.has_client_type()) {
      set_client_type(from.client_type());
    }
    if (from.has_client_version()) {
      set_client_version(from.client_version());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

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

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

  return true;
}

void IMLoginReq::Swap(IMLoginReq* other) {
  if (other != this) {
    std::swap(user_name_, other->user_name_);
    std::swap(password_, other->password_);
    std::swap(online_status_, other->online_status_);
    std::swap(client_type_, other->client_type_);
    std::swap(client_version_, other->client_version_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string IMLoginReq::GetTypeName() const {
  return "IM.Login.IMLoginReq";
}

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

#ifndef _MSC_VER
const int IMLoginRes::kServerTimeFieldNumber;
const int IMLoginRes::kResultCodeFieldNumber;
const int IMLoginRes::kResultStringFieldNumber;
const int IMLoginRes::kOnlineStatusFieldNumber;
const int IMLoginRes::kUserInfoFieldNumber;
#endif  // !_MSC_VER

IMLoginRes::IMLoginRes()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:IM.Login.IMLoginRes)
}

void IMLoginRes::InitAsDefaultInstance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  user_info_ = const_cast< ::IM::BaseDefine::UserInfo*>(
      ::IM::BaseDefine::UserInfo::internal_default_instance());
#else
  user_info_ = const_cast< ::IM::BaseDefine::UserInfo*>(&::IM::BaseDefine::UserInfo::default_instance());
#endif
}

IMLoginRes::IMLoginRes(const IMLoginRes& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:IM.Login.IMLoginRes)
}

void IMLoginRes::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  server_time_ = 0u;
  result_code_ = 0;
  result_string_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  online_status_ = 1;
  user_info_ = NULL;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

IMLoginRes::~IMLoginRes() {
  // @@protoc_insertion_point(destructor:IM.Login.IMLoginRes)
  SharedDtor();
}

void IMLoginRes::SharedDtor() {
  if (result_string_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete result_string_;
  }
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
    delete user_info_;
  }
}

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

IMLoginRes* IMLoginRes::default_instance_ = NULL;

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

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

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  if (_has_bits_[0 / 32] & 31) {
    ZR_(server_time_, result_code_);
    if (has_result_string()) {
      if (result_string_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        result_string_->clear();
      }
    }
    online_status_ = 1;
    if (has_user_info()) {
      if (user_info_ != NULL) user_info_->::IM::BaseDefine::UserInfo::Clear();
    }
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool IMLoginRes::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:IM.Login.IMLoginRes)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 server_time = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &server_time_)));
          set_has_server_time();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_result_code;
        break;
      }

      // required .IM.BaseDefine.ResultType result_code = 2;
      case 2: {
        if (tag == 16) {
         parse_result_code:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::IM::BaseDefine::ResultType_IsValid(value)) {
            set_result_code(static_cast< ::IM::BaseDefine::ResultType >(value));
          } else {
            unknown_fields_stream.WriteVarint32(tag);
            unknown_fields_stream.WriteVarint32(value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_result_string;
        break;
      }

      // optional string result_string = 3;
      case 3: {
        if (tag == 26) {
         parse_result_string:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_result_string()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(32)) goto parse_online_status;
        break;
      }

      // optional .IM.BaseDefine.UserStatType online_status = 4;
      case 4: {
        if (tag == 32) {
         parse_online_status:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::IM::BaseDefine::UserStatType_IsValid(value)) {
            set_online_status(static_cast< ::IM::BaseDefine::UserStatType >(value));
          } else {
            unknown_fields_stream.WriteVarint32(tag);
            unknown_fields_stream.WriteVarint32(value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(42)) goto parse_user_info;
        break;
      }

      // optional .IM.BaseDefine.UserInfo user_info = 5;
      case 5: {
        if (tag == 42) {
         parse_user_info:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_user_info()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:IM.Login.IMLoginRes)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:IM.Login.IMLoginRes)
  return false;
#undef DO_
}

void IMLoginRes::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:IM.Login.IMLoginRes)
  // required uint32 server_time = 1;
  if (has_server_time()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->server_time(), output);
  }

  // required .IM.BaseDefine.ResultType result_code = 2;
  if (has_result_code()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      2, this->result_code(), output);
  }

  // optional string result_string = 3;
  if (has_result_string()) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      3, this->result_string(), output);
  }

  // optional .IM.BaseDefine.UserStatType online_status = 4;
  if (has_online_status()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      4, this->online_status(), output);
  }

  // optional .IM.BaseDefine.UserInfo user_info = 5;
  if (has_user_info()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      5, this->user_info(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:IM.Login.IMLoginRes)
}

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

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

    // required .IM.BaseDefine.ResultType result_code = 2;
    if (has_result_code()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->result_code());
    }

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

    // optional .IM.BaseDefine.UserStatType online_status = 4;
    if (has_online_status()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->online_status());
    }

    // optional .IM.BaseDefine.UserInfo user_info = 5;
    if (has_user_info()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->user_info());
    }

  }
  total_size += unknown_fields().size();

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

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

void IMLoginRes::MergeFrom(const IMLoginRes& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_server_time()) {
      set_server_time(from.server_time());
    }
    if (from.has_result_code()) {
      set_result_code(from.result_code());
    }
    if (from.has_result_string()) {
      set_result_string(from.result_string());
    }
    if (from.has_online_status()) {
      set_online_status(from.online_status());
    }
    if (from.has_user_info()) {
      mutable_user_info()->::IM::BaseDefine::UserInfo::MergeFrom(from.user_info());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

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

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

  if (has_user_info()) {
    if (!this->user_info().IsInitialized()) return false;
  }
  return true;
}

void IMLoginRes::Swap(IMLoginRes* other) {
  if (other != this) {
    std::swap(server_time_, other->server_time_);
    std::swap(result_code_, other->result_code_);
    std::swap(result_string_, other->result_string_);
    std::swap(online_status_, other->online_status_);
    std::swap(user_info_, other->user_info_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string IMLoginRes::GetTypeName() const {
  return "IM.Login.IMLoginRes";
}

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

#ifndef _MSC_VER
#endif  // !_MSC_VER

IMLogoutReq::IMLogoutReq()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:IM.Login.IMLogoutReq)
}

void IMLogoutReq::InitAsDefaultInstance() {
}

IMLogoutReq::IMLogoutReq(const IMLogoutReq& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:IM.Login.IMLogoutReq)
}

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

IMLogoutReq::~IMLogoutReq() {
  // @@protoc_insertion_point(destructor:IM.Login.IMLogoutReq)
  SharedDtor();
}

void IMLogoutReq::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

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

IMLogoutReq* IMLogoutReq::default_instance_ = NULL;

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

void IMLogoutReq::Clear() {
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool IMLogoutReq::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:IM.Login.IMLogoutReq)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    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:IM.Login.IMLogoutReq)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:IM.Login.IMLogoutReq)
  return false;
#undef DO_
}

void IMLogoutReq::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:IM.Login.IMLogoutReq)
  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:IM.Login.IMLogoutReq)
}

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

  total_size += unknown_fields().size();

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

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

void IMLogoutReq::MergeFrom(const IMLogoutReq& from) {
  GOOGLE_CHECK_NE(&from, this);
  mutable_unknown_fields()->append(from.unknown_fields());
}

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

bool IMLogoutReq::IsInitialized() const {

  return true;
}

void IMLogoutReq::Swap(IMLogoutReq* other) {
  if (other != this) {
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string IMLogoutReq::GetTypeName() const {
  return "IM.Login.IMLogoutReq";
}

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

#ifndef _MSC_VER
const int IMLogoutRsp::kResultCodeFieldNumber;
#endif  // !_MSC_VER

IMLogoutRsp::IMLogoutRsp()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:IM.Login.IMLogoutRsp)
}

void IMLogoutRsp::InitAsDefaultInstance() {
}

IMLogoutRsp::IMLogoutRsp(const IMLogoutRsp& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:IM.Login.IMLogoutRsp)
}

void IMLogoutRsp::SharedCtor() {
  _cached_size_ = 0;
  result_code_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

IMLogoutRsp::~IMLogoutRsp() {
  // @@protoc_insertion_point(destructor:IM.Login.IMLogoutRsp)
  SharedDtor();
}

void IMLogoutRsp::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

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

IMLogoutRsp* IMLogoutRsp::default_instance_ = NULL;

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

void IMLogoutRsp::Clear() {
  result_code_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool IMLogoutRsp::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:IM.Login.IMLogoutRsp)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 result_code = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &result_code_)));
          set_has_result_code();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:IM.Login.IMLogoutRsp)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:IM.Login.IMLogoutRsp)
  return false;
#undef DO_
}

void IMLogoutRsp::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:IM.Login.IMLogoutRsp)
  // required uint32 result_code = 1;
  if (has_result_code()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->result_code(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:IM.Login.IMLogoutRsp)
}

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

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

  }
  total_size += unknown_fields().size();

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

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

void IMLogoutRsp::MergeFrom(const IMLogoutRsp& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_result_code()) {
      set_result_code(from.result_code());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

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

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

  return true;
}

void IMLogoutRsp::Swap(IMLogoutRsp* other) {
  if (other != this) {
    std::swap(result_code_, other->result_code_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string IMLogoutRsp::GetTypeName() const {
  return "IM.Login.IMLogoutRsp";
}

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

#ifndef _MSC_VER
const int IMKickUser::kUserIdFieldNumber;
const int IMKickUser::kKickReasonFieldNumber;
#endif  // !_MSC_VER

IMKickUser::IMKickUser()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:IM.Login.IMKickUser)
}

void IMKickUser::InitAsDefaultInstance() {
}

IMKickUser::IMKickUser(const IMKickUser& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:IM.Login.IMKickUser)
}

void IMKickUser::SharedCtor() {
  _cached_size_ = 0;
  user_id_ = 0u;
  kick_reason_ = 1;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

IMKickUser::~IMKickUser() {
  // @@protoc_insertion_point(destructor:IM.Login.IMKickUser)
  SharedDtor();
}

void IMKickUser::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

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

IMKickUser* IMKickUser::default_instance_ = NULL;

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

void IMKickUser::Clear() {
  if (_has_bits_[0 / 32] & 3) {
    user_id_ = 0u;
    kick_reason_ = 1;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool IMKickUser::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:IM.Login.IMKickUser)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 user_id = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &user_id_)));
          set_has_user_id();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_kick_reason;
        break;
      }

      // required .IM.BaseDefine.KickReasonType kick_reason = 2;
      case 2: {
        if (tag == 16) {
         parse_kick_reason:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::IM::BaseDefine::KickReasonType_IsValid(value)) {
            set_kick_reason(static_cast< ::IM::BaseDefine::KickReasonType >(value));
          } else {
            unknown_fields_stream.WriteVarint32(tag);
            unknown_fields_stream.WriteVarint32(value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:IM.Login.IMKickUser)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:IM.Login.IMKickUser)
  return false;
#undef DO_
}

void IMKickUser::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:IM.Login.IMKickUser)
  // required uint32 user_id = 1;
  if (has_user_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->user_id(), output);
  }

  // required .IM.BaseDefine.KickReasonType kick_reason = 2;
  if (has_kick_reason()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      2, this->kick_reason(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:IM.Login.IMKickUser)
}

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

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

    // required .IM.BaseDefine.KickReasonType kick_reason = 2;
    if (has_kick_reason()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->kick_reason());
    }

  }
  total_size += unknown_fields().size();

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

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

void IMKickUser::MergeFrom(const IMKickUser& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_user_id()) {
      set_user_id(from.user_id());
    }
    if (from.has_kick_reason()) {
      set_kick_reason(from.kick_reason());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

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

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

  return true;
}

void IMKickUser::Swap(IMKickUser* other) {
  if (other != this) {
    std::swap(user_id_, other->user_id_);
    std::swap(kick_reason_, other->kick_reason_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string IMKickUser::GetTypeName() const {
  return "IM.Login.IMKickUser";
}

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

#ifndef _MSC_VER
const int IMDeviceTokenReq::kUserIdFieldNumber;
const int IMDeviceTokenReq::kDeviceTokenFieldNumber;
const int IMDeviceTokenReq::kClientTypeFieldNumber;
const int IMDeviceTokenReq::kAttachDataFieldNumber;
#endif  // !_MSC_VER

IMDeviceTokenReq::IMDeviceTokenReq()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:IM.Login.IMDeviceTokenReq)
}

void IMDeviceTokenReq::InitAsDefaultInstance() {
}

IMDeviceTokenReq::IMDeviceTokenReq(const IMDeviceTokenReq& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:IM.Login.IMDeviceTokenReq)
}

void IMDeviceTokenReq::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  user_id_ = 0u;
  device_token_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  client_type_ = 1;
  attach_data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

IMDeviceTokenReq::~IMDeviceTokenReq() {
  // @@protoc_insertion_point(destructor:IM.Login.IMDeviceTokenReq)
  SharedDtor();
}

void IMDeviceTokenReq::SharedDtor() {
  if (device_token_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete device_token_;
  }
  if (attach_data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete attach_data_;
  }
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

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

IMDeviceTokenReq* IMDeviceTokenReq::default_instance_ = NULL;

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

void IMDeviceTokenReq::Clear() {
  if (_has_bits_[0 / 32] & 15) {
    user_id_ = 0u;
    if (has_device_token()) {
      if (device_token_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        device_token_->clear();
      }
    }
    client_type_ = 1;
    if (has_attach_data()) {
      if (attach_data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        attach_data_->clear();
      }
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool IMDeviceTokenReq::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:IM.Login.IMDeviceTokenReq)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(16383);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 user_id = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &user_id_)));
          set_has_user_id();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_device_token;
        break;
      }

      // required string device_token = 2;
      case 2: {
        if (tag == 18) {
         parse_device_token:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_device_token()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_client_type;
        break;
      }

      // optional .IM.BaseDefine.ClientType client_type = 3;
      case 3: {
        if (tag == 24) {
         parse_client_type:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::IM::BaseDefine::ClientType_IsValid(value)) {
            set_client_type(static_cast< ::IM::BaseDefine::ClientType >(value));
          } else {
            unknown_fields_stream.WriteVarint32(tag);
            unknown_fields_stream.WriteVarint32(value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(162)) goto parse_attach_data;
        break;
      }

      // optional bytes attach_data = 20;
      case 20: {
        if (tag == 162) {
         parse_attach_data:
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_attach_data()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:IM.Login.IMDeviceTokenReq)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:IM.Login.IMDeviceTokenReq)
  return false;
#undef DO_
}

void IMDeviceTokenReq::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:IM.Login.IMDeviceTokenReq)
  // required uint32 user_id = 1;
  if (has_user_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->user_id(), output);
  }

  // required string device_token = 2;
  if (has_device_token()) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      2, this->device_token(), output);
  }

  // optional .IM.BaseDefine.ClientType client_type = 3;
  if (has_client_type()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      3, this->client_type(), output);
  }

  // optional bytes attach_data = 20;
  if (has_attach_data()) {
    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
      20, this->attach_data(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:IM.Login.IMDeviceTokenReq)
}

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

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

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

    // optional .IM.BaseDefine.ClientType client_type = 3;
    if (has_client_type()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->client_type());
    }

    // optional bytes attach_data = 20;
    if (has_attach_data()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->attach_data());
    }

  }
  total_size += unknown_fields().size();

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

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

void IMDeviceTokenReq::MergeFrom(const IMDeviceTokenReq& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_user_id()) {
      set_user_id(from.user_id());
    }
    if (from.has_device_token()) {
      set_device_token(from.device_token());
    }
    if (from.has_client_type()) {
      set_client_type(from.client_type());
    }
    if (from.has_attach_data()) {
      set_attach_data(from.attach_data());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

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

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

  return true;
}

void IMDeviceTokenReq::Swap(IMDeviceTokenReq* other) {
  if (other != this) {
    std::swap(user_id_, other->user_id_);
    std::swap(device_token_, other->device_token_);
    std::swap(client_type_, other->client_type_);
    std::swap(attach_data_, other->attach_data_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string IMDeviceTokenReq::GetTypeName() const {
  return "IM.Login.IMDeviceTokenReq";
}

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

#ifndef _MSC_VER
const int IMDeviceTokenRsp::kUserIdFieldNumber;
const int IMDeviceTokenRsp::kAttachDataFieldNumber;
#endif  // !_MSC_VER

IMDeviceTokenRsp::IMDeviceTokenRsp()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:IM.Login.IMDeviceTokenRsp)
}

void IMDeviceTokenRsp::InitAsDefaultInstance() {
}

IMDeviceTokenRsp::IMDeviceTokenRsp(const IMDeviceTokenRsp& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:IM.Login.IMDeviceTokenRsp)
}

void IMDeviceTokenRsp::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  user_id_ = 0u;
  attach_data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

IMDeviceTokenRsp::~IMDeviceTokenRsp() {
  // @@protoc_insertion_point(destructor:IM.Login.IMDeviceTokenRsp)
  SharedDtor();
}

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

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

IMDeviceTokenRsp* IMDeviceTokenRsp::default_instance_ = NULL;

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

void IMDeviceTokenRsp::Clear() {
  if (_has_bits_[0 / 32] & 3) {
    user_id_ = 0u;
    if (has_attach_data()) {
      if (attach_data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        attach_data_->clear();
      }
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool IMDeviceTokenRsp::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:IM.Login.IMDeviceTokenRsp)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(16383);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 user_id = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &user_id_)));
          set_has_user_id();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(162)) goto parse_attach_data;
        break;
      }

      // optional bytes attach_data = 20;
      case 20: {
        if (tag == 162) {
         parse_attach_data:
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_attach_data()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:IM.Login.IMDeviceTokenRsp)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:IM.Login.IMDeviceTokenRsp)
  return false;
#undef DO_
}

void IMDeviceTokenRsp::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:IM.Login.IMDeviceTokenRsp)
  // required uint32 user_id = 1;
  if (has_user_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->user_id(), output);
  }

  // optional bytes attach_data = 20;
  if (has_attach_data()) {
    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
      20, this->attach_data(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:IM.Login.IMDeviceTokenRsp)
}

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

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

    // optional bytes attach_data = 20;
    if (has_attach_data()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->attach_data());
    }

  }
  total_size += unknown_fields().size();

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

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

void IMDeviceTokenRsp::MergeFrom(const IMDeviceTokenRsp& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_user_id()) {
      set_user_id(from.user_id());
    }
    if (from.has_attach_data()) {
      set_attach_data(from.attach_data());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

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

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

  return true;
}

void IMDeviceTokenRsp::Swap(IMDeviceTokenRsp* other) {
  if (other != this) {
    std::swap(user_id_, other->user_id_);
    std::swap(attach_data_, other->attach_data_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string IMDeviceTokenRsp::GetTypeName() const {
  return "IM.Login.IMDeviceTokenRsp";
}

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

#ifndef _MSC_VER
const int IMKickPCClientReq::kUserIdFieldNumber;
#endif  // !_MSC_VER

IMKickPCClientReq::IMKickPCClientReq()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:IM.Login.IMKickPCClientReq)
}

void IMKickPCClientReq::InitAsDefaultInstance() {
}

IMKickPCClientReq::IMKickPCClientReq(const IMKickPCClientReq& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:IM.Login.IMKickPCClientReq)
}

void IMKickPCClientReq::SharedCtor() {
  _cached_size_ = 0;
  user_id_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

IMKickPCClientReq::~IMKickPCClientReq() {
  // @@protoc_insertion_point(destructor:IM.Login.IMKickPCClientReq)
  SharedDtor();
}

void IMKickPCClientReq::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

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

IMKickPCClientReq* IMKickPCClientReq::default_instance_ = NULL;

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

void IMKickPCClientReq::Clear() {
  user_id_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool IMKickPCClientReq::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:IM.Login.IMKickPCClientReq)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 user_id = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &user_id_)));
          set_has_user_id();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:IM.Login.IMKickPCClientReq)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:IM.Login.IMKickPCClientReq)
  return false;
#undef DO_
}

void IMKickPCClientReq::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:IM.Login.IMKickPCClientReq)
  // required uint32 user_id = 1;
  if (has_user_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->user_id(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:IM.Login.IMKickPCClientReq)
}

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

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

  }
  total_size += unknown_fields().size();

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

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

void IMKickPCClientReq::MergeFrom(const IMKickPCClientReq& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_user_id()) {
      set_user_id(from.user_id());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

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

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

  return true;
}

void IMKickPCClientReq::Swap(IMKickPCClientReq* other) {
  if (other != this) {
    std::swap(user_id_, other->user_id_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string IMKickPCClientReq::GetTypeName() const {
  return "IM.Login.IMKickPCClientReq";
}

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

#ifndef _MSC_VER
const int IMKickPCClientRsp::kUserIdFieldNumber;
const int IMKickPCClientRsp::kResultCodeFieldNumber;
#endif  // !_MSC_VER

IMKickPCClientRsp::IMKickPCClientRsp()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:IM.Login.IMKickPCClientRsp)
}

void IMKickPCClientRsp::InitAsDefaultInstance() {
}

IMKickPCClientRsp::IMKickPCClientRsp(const IMKickPCClientRsp& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:IM.Login.IMKickPCClientRsp)
}

void IMKickPCClientRsp::SharedCtor() {
  _cached_size_ = 0;
  user_id_ = 0u;
  result_code_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

IMKickPCClientRsp::~IMKickPCClientRsp() {
  // @@protoc_insertion_point(destructor:IM.Login.IMKickPCClientRsp)
  SharedDtor();
}

void IMKickPCClientRsp::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

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

IMKickPCClientRsp* IMKickPCClientRsp::default_instance_ = NULL;

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

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

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  ZR_(user_id_, result_code_);

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool IMKickPCClientRsp::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:IM.Login.IMKickPCClientRsp)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 user_id = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &user_id_)));
          set_has_user_id();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_result_code;
        break;
      }

      // required uint32 result_code = 2;
      case 2: {
        if (tag == 16) {
         parse_result_code:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &result_code_)));
          set_has_result_code();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:IM.Login.IMKickPCClientRsp)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:IM.Login.IMKickPCClientRsp)
  return false;
#undef DO_
}

void IMKickPCClientRsp::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:IM.Login.IMKickPCClientRsp)
  // required uint32 user_id = 1;
  if (has_user_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->user_id(), output);
  }

  // required uint32 result_code = 2;
  if (has_result_code()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->result_code(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:IM.Login.IMKickPCClientRsp)
}

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

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

    // required uint32 result_code = 2;
    if (has_result_code()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->result_code());
    }

  }
  total_size += unknown_fields().size();

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

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

void IMKickPCClientRsp::MergeFrom(const IMKickPCClientRsp& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_user_id()) {
      set_user_id(from.user_id());
    }
    if (from.has_result_code()) {
      set_result_code(from.result_code());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

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

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

  return true;
}

void IMKickPCClientRsp::Swap(IMKickPCClientRsp* other) {
  if (other != this) {
    std::swap(user_id_, other->user_id_);
    std::swap(result_code_, other->result_code_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string IMKickPCClientRsp::GetTypeName() const {
  return "IM.Login.IMKickPCClientRsp";
}

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

#ifndef _MSC_VER
const int IMPushShieldReq::kUserIdFieldNumber;
const int IMPushShieldReq::kShieldStatusFieldNumber;
const int IMPushShieldReq::kAttachDataFieldNumber;
#endif  // !_MSC_VER

IMPushShieldReq::IMPushShieldReq()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:IM.Login.IMPushShieldReq)
}

void IMPushShieldReq::InitAsDefaultInstance() {
}

IMPushShieldReq::IMPushShieldReq(const IMPushShieldReq& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:IM.Login.IMPushShieldReq)
}

void IMPushShieldReq::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  user_id_ = 0u;
  shield_status_ = 0u;
  attach_data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

IMPushShieldReq::~IMPushShieldReq() {
  // @@protoc_insertion_point(destructor:IM.Login.IMPushShieldReq)
  SharedDtor();
}

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

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

IMPushShieldReq* IMPushShieldReq::default_instance_ = NULL;

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

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

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  if (_has_bits_[0 / 32] & 7) {
    ZR_(user_id_, shield_status_);
    if (has_attach_data()) {
      if (attach_data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        attach_data_->clear();
      }
    }
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool IMPushShieldReq::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:IM.Login.IMPushShieldReq)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(16383);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 user_id = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &user_id_)));
          set_has_user_id();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_shield_status;
        break;
      }

      // required uint32 shield_status = 2;
      case 2: {
        if (tag == 16) {
         parse_shield_status:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &shield_status_)));
          set_has_shield_status();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(162)) goto parse_attach_data;
        break;
      }

      // optional bytes attach_data = 20;
      case 20: {
        if (tag == 162) {
         parse_attach_data:
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_attach_data()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:IM.Login.IMPushShieldReq)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:IM.Login.IMPushShieldReq)
  return false;
#undef DO_
}

void IMPushShieldReq::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:IM.Login.IMPushShieldReq)
  // required uint32 user_id = 1;
  if (has_user_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->user_id(), output);
  }

  // required uint32 shield_status = 2;
  if (has_shield_status()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->shield_status(), output);
  }

  // optional bytes attach_data = 20;
  if (has_attach_data()) {
    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
      20, this->attach_data(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:IM.Login.IMPushShieldReq)
}

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

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

    // required uint32 shield_status = 2;
    if (has_shield_status()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->shield_status());
    }

    // optional bytes attach_data = 20;
    if (has_attach_data()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->attach_data());
    }

  }
  total_size += unknown_fields().size();

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

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

void IMPushShieldReq::MergeFrom(const IMPushShieldReq& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_user_id()) {
      set_user_id(from.user_id());
    }
    if (from.has_shield_status()) {
      set_shield_status(from.shield_status());
    }
    if (from.has_attach_data()) {
      set_attach_data(from.attach_data());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

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

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

  return true;
}

void IMPushShieldReq::Swap(IMPushShieldReq* other) {
  if (other != this) {
    std::swap(user_id_, other->user_id_);
    std::swap(shield_status_, other->shield_status_);
    std::swap(attach_data_, other->attach_data_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string IMPushShieldReq::GetTypeName() const {
  return "IM.Login.IMPushShieldReq";
}

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

#ifndef _MSC_VER
const int IMPushShieldRsp::kUserIdFieldNumber;
const int IMPushShieldRsp::kResultCodeFieldNumber;
const int IMPushShieldRsp::kShieldStatusFieldNumber;
const int IMPushShieldRsp::kAttachDataFieldNumber;
#endif  // !_MSC_VER

IMPushShieldRsp::IMPushShieldRsp()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:IM.Login.IMPushShieldRsp)
}

void IMPushShieldRsp::InitAsDefaultInstance() {
}

IMPushShieldRsp::IMPushShieldRsp(const IMPushShieldRsp& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:IM.Login.IMPushShieldRsp)
}

void IMPushShieldRsp::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  user_id_ = 0u;
  result_code_ = 0u;
  shield_status_ = 0u;
  attach_data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

IMPushShieldRsp::~IMPushShieldRsp() {
  // @@protoc_insertion_point(destructor:IM.Login.IMPushShieldRsp)
  SharedDtor();
}

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

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

IMPushShieldRsp* IMPushShieldRsp::default_instance_ = NULL;

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

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

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  if (_has_bits_[0 / 32] & 15) {
    ZR_(user_id_, result_code_);
    shield_status_ = 0u;
    if (has_attach_data()) {
      if (attach_data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        attach_data_->clear();
      }
    }
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool IMPushShieldRsp::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:IM.Login.IMPushShieldRsp)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(16383);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 user_id = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &user_id_)));
          set_has_user_id();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_result_code;
        break;
      }

      // required uint32 result_code = 2;
      case 2: {
        if (tag == 16) {
         parse_result_code:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &result_code_)));
          set_has_result_code();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_shield_status;
        break;
      }

      // optional uint32 shield_status = 3;
      case 3: {
        if (tag == 24) {
         parse_shield_status:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &shield_status_)));
          set_has_shield_status();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(162)) goto parse_attach_data;
        break;
      }

      // optional bytes attach_data = 20;
      case 20: {
        if (tag == 162) {
         parse_attach_data:
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_attach_data()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:IM.Login.IMPushShieldRsp)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:IM.Login.IMPushShieldRsp)
  return false;
#undef DO_
}

void IMPushShieldRsp::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:IM.Login.IMPushShieldRsp)
  // required uint32 user_id = 1;
  if (has_user_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->user_id(), output);
  }

  // required uint32 result_code = 2;
  if (has_result_code()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->result_code(), output);
  }

  // optional uint32 shield_status = 3;
  if (has_shield_status()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->shield_status(), output);
  }

  // optional bytes attach_data = 20;
  if (has_attach_data()) {
    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
      20, this->attach_data(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:IM.Login.IMPushShieldRsp)
}

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

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

    // required uint32 result_code = 2;
    if (has_result_code()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->result_code());
    }

    // optional uint32 shield_status = 3;
    if (has_shield_status()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->shield_status());
    }

    // optional bytes attach_data = 20;
    if (has_attach_data()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->attach_data());
    }

  }
  total_size += unknown_fields().size();

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

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

void IMPushShieldRsp::MergeFrom(const IMPushShieldRsp& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_user_id()) {
      set_user_id(from.user_id());
    }
    if (from.has_result_code()) {
      set_result_code(from.result_code());
    }
    if (from.has_shield_status()) {
      set_shield_status(from.shield_status());
    }
    if (from.has_attach_data()) {
      set_attach_data(from.attach_data());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

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

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

  return true;
}

void IMPushShieldRsp::Swap(IMPushShieldRsp* other) {
  if (other != this) {
    std::swap(user_id_, other->user_id_);
    std::swap(result_code_, other->result_code_);
    std::swap(shield_status_, other->shield_status_);
    std::swap(attach_data_, other->attach_data_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string IMPushShieldRsp::GetTypeName() const {
  return "IM.Login.IMPushShieldRsp";
}

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

#ifndef _MSC_VER
const int IMQueryPushShieldReq::kUserIdFieldNumber;
const int IMQueryPushShieldReq::kAttachDataFieldNumber;
#endif  // !_MSC_VER

IMQueryPushShieldReq::IMQueryPushShieldReq()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:IM.Login.IMQueryPushShieldReq)
}

void IMQueryPushShieldReq::InitAsDefaultInstance() {
}

IMQueryPushShieldReq::IMQueryPushShieldReq(const IMQueryPushShieldReq& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:IM.Login.IMQueryPushShieldReq)
}

void IMQueryPushShieldReq::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  user_id_ = 0u;
  attach_data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

IMQueryPushShieldReq::~IMQueryPushShieldReq() {
  // @@protoc_insertion_point(destructor:IM.Login.IMQueryPushShieldReq)
  SharedDtor();
}

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

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

IMQueryPushShieldReq* IMQueryPushShieldReq::default_instance_ = NULL;

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

void IMQueryPushShieldReq::Clear() {
  if (_has_bits_[0 / 32] & 3) {
    user_id_ = 0u;
    if (has_attach_data()) {
      if (attach_data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        attach_data_->clear();
      }
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool IMQueryPushShieldReq::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:IM.Login.IMQueryPushShieldReq)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(16383);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 user_id = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &user_id_)));
          set_has_user_id();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(162)) goto parse_attach_data;
        break;
      }

      // optional bytes attach_data = 20;
      case 20: {
        if (tag == 162) {
         parse_attach_data:
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_attach_data()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:IM.Login.IMQueryPushShieldReq)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:IM.Login.IMQueryPushShieldReq)
  return false;
#undef DO_
}

void IMQueryPushShieldReq::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:IM.Login.IMQueryPushShieldReq)
  // required uint32 user_id = 1;
  if (has_user_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->user_id(), output);
  }

  // optional bytes attach_data = 20;
  if (has_attach_data()) {
    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
      20, this->attach_data(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:IM.Login.IMQueryPushShieldReq)
}

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

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

    // optional bytes attach_data = 20;
    if (has_attach_data()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->attach_data());
    }

  }
  total_size += unknown_fields().size();

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

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

void IMQueryPushShieldReq::MergeFrom(const IMQueryPushShieldReq& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_user_id()) {
      set_user_id(from.user_id());
    }
    if (from.has_attach_data()) {
      set_attach_data(from.attach_data());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

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

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

  return true;
}

void IMQueryPushShieldReq::Swap(IMQueryPushShieldReq* other) {
  if (other != this) {
    std::swap(user_id_, other->user_id_);
    std::swap(attach_data_, other->attach_data_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string IMQueryPushShieldReq::GetTypeName() const {
  return "IM.Login.IMQueryPushShieldReq";
}

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

#ifndef _MSC_VER
const int IMQueryPushShieldRsp::kUserIdFieldNumber;
const int IMQueryPushShieldRsp::kResultCodeFieldNumber;
const int IMQueryPushShieldRsp::kShieldStatusFieldNumber;
const int IMQueryPushShieldRsp::kAttachDataFieldNumber;
#endif  // !_MSC_VER

IMQueryPushShieldRsp::IMQueryPushShieldRsp()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:IM.Login.IMQueryPushShieldRsp)
}

void IMQueryPushShieldRsp::InitAsDefaultInstance() {
}

IMQueryPushShieldRsp::IMQueryPushShieldRsp(const IMQueryPushShieldRsp& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:IM.Login.IMQueryPushShieldRsp)
}

void IMQueryPushShieldRsp::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  user_id_ = 0u;
  result_code_ = 0u;
  shield_status_ = 0u;
  attach_data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

IMQueryPushShieldRsp::~IMQueryPushShieldRsp() {
  // @@protoc_insertion_point(destructor:IM.Login.IMQueryPushShieldRsp)
  SharedDtor();
}

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

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

IMQueryPushShieldRsp* IMQueryPushShieldRsp::default_instance_ = NULL;

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

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

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  if (_has_bits_[0 / 32] & 15) {
    ZR_(user_id_, result_code_);
    shield_status_ = 0u;
    if (has_attach_data()) {
      if (attach_data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        attach_data_->clear();
      }
    }
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool IMQueryPushShieldRsp::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:IM.Login.IMQueryPushShieldRsp)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(16383);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 user_id = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &user_id_)));
          set_has_user_id();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_result_code;
        break;
      }

      // required uint32 result_code = 2;
      case 2: {
        if (tag == 16) {
         parse_result_code:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &result_code_)));
          set_has_result_code();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_shield_status;
        break;
      }

      // optional uint32 shield_status = 3;
      case 3: {
        if (tag == 24) {
         parse_shield_status:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &shield_status_)));
          set_has_shield_status();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(162)) goto parse_attach_data;
        break;
      }

      // optional bytes attach_data = 20;
      case 20: {
        if (tag == 162) {
         parse_attach_data:
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_attach_data()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:IM.Login.IMQueryPushShieldRsp)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:IM.Login.IMQueryPushShieldRsp)
  return false;
#undef DO_
}

void IMQueryPushShieldRsp::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:IM.Login.IMQueryPushShieldRsp)
  // required uint32 user_id = 1;
  if (has_user_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->user_id(), output);
  }

  // required uint32 result_code = 2;
  if (has_result_code()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->result_code(), output);
  }

  // optional uint32 shield_status = 3;
  if (has_shield_status()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->shield_status(), output);
  }

  // optional bytes attach_data = 20;
  if (has_attach_data()) {
    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
      20, this->attach_data(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:IM.Login.IMQueryPushShieldRsp)
}

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

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

    // required uint32 result_code = 2;
    if (has_result_code()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->result_code());
    }

    // optional uint32 shield_status = 3;
    if (has_shield_status()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->shield_status());
    }

    // optional bytes attach_data = 20;
    if (has_attach_data()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->attach_data());
    }

  }
  total_size += unknown_fields().size();

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

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

void IMQueryPushShieldRsp::MergeFrom(const IMQueryPushShieldRsp& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_user_id()) {
      set_user_id(from.user_id());
    }
    if (from.has_result_code()) {
      set_result_code(from.result_code());
    }
    if (from.has_shield_status()) {
      set_shield_status(from.shield_status());
    }
    if (from.has_attach_data()) {
      set_attach_data(from.attach_data());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

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

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

  return true;
}

void IMQueryPushShieldRsp::Swap(IMQueryPushShieldRsp* other) {
  if (other != this) {
    std::swap(user_id_, other->user_id_);
    std::swap(result_code_, other->result_code_);
    std::swap(shield_status_, other->shield_status_);
    std::swap(attach_data_, other->attach_data_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string IMQueryPushShieldRsp::GetTypeName() const {
  return "IM.Login.IMQueryPushShieldRsp";
}

// @@protoc_insertion_point(namespace_scope)

}  // namespace Login
}  // namespace IM

// @@protoc_insertion_point(global_scope)