
#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
#include "IM.File.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 File {

void protobuf_ShutdownFile_IM_2eFile_2eproto() {
  delete IMFileLoginReq::default_instance_;
  delete IMFileLoginRsp::default_instance_;
  delete IMFileState::default_instance_;
  delete IMFilePullDataReq::default_instance_;
  delete IMFilePullDataRsp::default_instance_;
  delete IMFileReq::default_instance_;
  delete IMFileRsp::default_instance_;
  delete IMFileNotify::default_instance_;
  delete IMFileHasOfflineReq::default_instance_;
  delete IMFileHasOfflineRsp::default_instance_;
  delete IMFileAddOfflineReq::default_instance_;
  delete IMFileDelOfflineReq::default_instance_;
}

#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
void protobuf_AddDesc_IM_2eFile_2eproto_impl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#else
void protobuf_AddDesc_IM_2eFile_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();
  IMFileLoginReq::default_instance_ = new IMFileLoginReq();
  IMFileLoginRsp::default_instance_ = new IMFileLoginRsp();
  IMFileState::default_instance_ = new IMFileState();
  IMFilePullDataReq::default_instance_ = new IMFilePullDataReq();
  IMFilePullDataRsp::default_instance_ = new IMFilePullDataRsp();
  IMFileReq::default_instance_ = new IMFileReq();
  IMFileRsp::default_instance_ = new IMFileRsp();
  IMFileNotify::default_instance_ = new IMFileNotify();
  IMFileHasOfflineReq::default_instance_ = new IMFileHasOfflineReq();
  IMFileHasOfflineRsp::default_instance_ = new IMFileHasOfflineRsp();
  IMFileAddOfflineReq::default_instance_ = new IMFileAddOfflineReq();
  IMFileDelOfflineReq::default_instance_ = new IMFileDelOfflineReq();
  IMFileLoginReq::default_instance_->InitAsDefaultInstance();
  IMFileLoginRsp::default_instance_->InitAsDefaultInstance();
  IMFileState::default_instance_->InitAsDefaultInstance();
  IMFilePullDataReq::default_instance_->InitAsDefaultInstance();
  IMFilePullDataRsp::default_instance_->InitAsDefaultInstance();
  IMFileReq::default_instance_->InitAsDefaultInstance();
  IMFileRsp::default_instance_->InitAsDefaultInstance();
  IMFileNotify::default_instance_->InitAsDefaultInstance();
  IMFileHasOfflineReq::default_instance_->InitAsDefaultInstance();
  IMFileHasOfflineRsp::default_instance_->InitAsDefaultInstance();
  IMFileAddOfflineReq::default_instance_->InitAsDefaultInstance();
  IMFileDelOfflineReq::default_instance_->InitAsDefaultInstance();
  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_IM_2eFile_2eproto);
}

#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AddDesc_IM_2eFile_2eproto_once_);
void protobuf_AddDesc_IM_2eFile_2eproto() {
  ::google::protobuf::GoogleOnceInit(&protobuf_AddDesc_IM_2eFile_2eproto_once_,
                 &protobuf_AddDesc_IM_2eFile_2eproto_impl);
}
#else
// Force AddDescriptors() to be called at static initialization time.
struct StaticDescriptorInitializer_IM_2eFile_2eproto {
  StaticDescriptorInitializer_IM_2eFile_2eproto() {
    protobuf_AddDesc_IM_2eFile_2eproto();
  }
} static_descriptor_initializer_IM_2eFile_2eproto_;
#endif

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

#ifndef _MSC_VER
const int IMFileLoginReq::kUserIdFieldNumber;
const int IMFileLoginReq::kTaskIdFieldNumber;
const int IMFileLoginReq::kFileRoleFieldNumber;
#endif  // !_MSC_VER

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

void IMFileLoginReq::InitAsDefaultInstance() {
}

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

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

IMFileLoginReq::~IMFileLoginReq() {
  // @@protoc_insertion_point(destructor:IM.File.IMFileLoginReq)
  SharedDtor();
}

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

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

IMFileLoginReq* IMFileLoginReq::default_instance_ = NULL;

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

void IMFileLoginReq::Clear() {
  if (_has_bits_[0 / 32] & 7) {
    user_id_ = 0u;
    if (has_task_id()) {
      if (task_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        task_id_->clear();
      }
    }
    file_role_ = 1;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool IMFileLoginReq::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.File.IMFileLoginReq)
  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(18)) goto parse_task_id;
        break;
      }

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

      // required .IM.BaseDefine.ClientFileRole file_role = 3;
      case 3: {
        if (tag == 24) {
         parse_file_role:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::IM::BaseDefine::ClientFileRole_IsValid(value)) {
            set_file_role(static_cast< ::IM::BaseDefine::ClientFileRole >(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.File.IMFileLoginReq)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:IM.File.IMFileLoginReq)
  return false;
#undef DO_
}

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

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

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

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

int IMFileLoginReq::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 task_id = 2;
    if (has_task_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->task_id());
    }

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

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

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

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

void IMFileLoginReq::MergeFrom(const IMFileLoginReq& 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_task_id()) {
      set_task_id(from.task_id());
    }
    if (from.has_file_role()) {
      set_file_role(from.file_role());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

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

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

  return true;
}

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

::std::string IMFileLoginReq::GetTypeName() const {
  return "IM.File.IMFileLoginReq";
}


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

#ifndef _MSC_VER
const int IMFileLoginRsp::kResultCodeFieldNumber;
const int IMFileLoginRsp::kTaskIdFieldNumber;
#endif  // !_MSC_VER

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

void IMFileLoginRsp::InitAsDefaultInstance() {
}

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

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

IMFileLoginRsp::~IMFileLoginRsp() {
  // @@protoc_insertion_point(destructor:IM.File.IMFileLoginRsp)
  SharedDtor();
}

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

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

IMFileLoginRsp* IMFileLoginRsp::default_instance_ = NULL;

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

void IMFileLoginRsp::Clear() {
  if (_has_bits_[0 / 32] & 3) {
    result_code_ = 0u;
    if (has_task_id()) {
      if (task_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        task_id_->clear();
      }
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool IMFileLoginRsp::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.File.IMFileLoginRsp)
  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->ExpectTag(18)) goto parse_task_id;
        break;
      }

      // required string task_id = 2;
      case 2: {
        if (tag == 18) {
         parse_task_id:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_task_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.File.IMFileLoginRsp)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:IM.File.IMFileLoginRsp)
  return false;
#undef DO_
}

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

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

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

int IMFileLoginRsp::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());
    }

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

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

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

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

void IMFileLoginRsp::MergeFrom(const IMFileLoginRsp& 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_task_id()) {
      set_task_id(from.task_id());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

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

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

  return true;
}

void IMFileLoginRsp::Swap(IMFileLoginRsp* other) {
  if (other != this) {
    std::swap(result_code_, other->result_code_);
    std::swap(task_id_, other->task_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 IMFileLoginRsp::GetTypeName() const {
  return "IM.File.IMFileLoginRsp";
}


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

#ifndef _MSC_VER
const int IMFileState::kStateFieldNumber;
const int IMFileState::kTaskIdFieldNumber;
const int IMFileState::kUserIdFieldNumber;
#endif  // !_MSC_VER

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

void IMFileState::InitAsDefaultInstance() {
}

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

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

IMFileState::~IMFileState() {
  // @@protoc_insertion_point(destructor:IM.File.IMFileState)
  SharedDtor();
}

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

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

IMFileState* IMFileState::default_instance_ = NULL;

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

void IMFileState::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<IMFileState*>(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_(state_, user_id_);
    if (has_task_id()) {
      if (task_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        task_id_->clear();
      }
    }
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

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

bool IMFileState::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.File.IMFileState)
  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.ClientFileState state = 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::ClientFileState_IsValid(value)) {
            set_state(static_cast< ::IM::BaseDefine::ClientFileState >(value));
          } else {
            unknown_fields_stream.WriteVarint32(tag);
            unknown_fields_stream.WriteVarint32(value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_task_id;
        break;
      }

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

      // required uint32 user_id = 3;
      case 3: {
        if (tag == 24) {
         parse_user_id:
          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.File.IMFileState)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:IM.File.IMFileState)
  return false;
#undef DO_
}

void IMFileState::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:IM.File.IMFileState)
  // required .IM.BaseDefine.ClientFileState state = 1;
  if (has_state()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->state(), output);
  }

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

  // required uint32 user_id = 3;
  if (has_user_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->user_id(), output);
  }

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

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

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

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

    // required uint32 user_id = 3;
    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 IMFileState::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const IMFileState*>(&from));
}

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

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

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

  return true;
}

void IMFileState::Swap(IMFileState* other) {
  if (other != this) {
    std::swap(state_, other->state_);
    std::swap(task_id_, other->task_id_);
    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 IMFileState::GetTypeName() const {
  return "IM.File.IMFileState";
}


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

#ifndef _MSC_VER
const int IMFilePullDataReq::kTaskIdFieldNumber;
const int IMFilePullDataReq::kUserIdFieldNumber;
const int IMFilePullDataReq::kTransModeFieldNumber;
const int IMFilePullDataReq::kOffsetFieldNumber;
const int IMFilePullDataReq::kDataSizeFieldNumber;
#endif  // !_MSC_VER

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

void IMFilePullDataReq::InitAsDefaultInstance() {
}

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

void IMFilePullDataReq::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  task_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  user_id_ = 0u;
  trans_mode_ = 1;
  offset_ = 0u;
  data_size_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

IMFilePullDataReq::~IMFilePullDataReq() {
  // @@protoc_insertion_point(destructor:IM.File.IMFilePullDataReq)
  SharedDtor();
}

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

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

IMFilePullDataReq* IMFilePullDataReq::default_instance_ = NULL;

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

void IMFilePullDataReq::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<IMFilePullDataReq*>(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_(offset_, data_size_);
    if (has_task_id()) {
      if (task_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        task_id_->clear();
      }
    }
    user_id_ = 0u;
    trans_mode_ = 1;
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

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

bool IMFilePullDataReq::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.File.IMFilePullDataReq)
  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 task_id = 1;
      case 1: {
        if (tag == 10) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_task_id()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_user_id;
        break;
      }

      // required uint32 user_id = 2;
      case 2: {
        if (tag == 16) {
         parse_user_id:
          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(24)) goto parse_trans_mode;
        break;
      }

      // required .IM.BaseDefine.TransferFileType trans_mode = 3;
      case 3: {
        if (tag == 24) {
         parse_trans_mode:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::IM::BaseDefine::TransferFileType_IsValid(value)) {
            set_trans_mode(static_cast< ::IM::BaseDefine::TransferFileType >(value));
          } else {
            unknown_fields_stream.WriteVarint32(tag);
            unknown_fields_stream.WriteVarint32(value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(32)) goto parse_offset;
        break;
      }

      // required uint32 offset = 4;
      case 4: {
        if (tag == 32) {
         parse_offset:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &offset_)));
          set_has_offset();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(40)) goto parse_data_size;
        break;
      }

      // required uint32 data_size = 5;
      case 5: {
        if (tag == 40) {
         parse_data_size:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &data_size_)));
          set_has_data_size();
        } 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.File.IMFilePullDataReq)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:IM.File.IMFilePullDataReq)
  return false;
#undef DO_
}

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

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

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

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

  // required uint32 data_size = 5;
  if (has_data_size()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(5, this->data_size(), output);
  }

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

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

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

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

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

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

    // required uint32 data_size = 5;
    if (has_data_size()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->data_size());
    }

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

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

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

void IMFilePullDataReq::MergeFrom(const IMFilePullDataReq& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_task_id()) {
      set_task_id(from.task_id());
    }
    if (from.has_user_id()) {
      set_user_id(from.user_id());
    }
    if (from.has_trans_mode()) {
      set_trans_mode(from.trans_mode());
    }
    if (from.has_offset()) {
      set_offset(from.offset());
    }
    if (from.has_data_size()) {
      set_data_size(from.data_size());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

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

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

  return true;
}

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

::std::string IMFilePullDataReq::GetTypeName() const {
  return "IM.File.IMFilePullDataReq";
}


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

#ifndef _MSC_VER
const int IMFilePullDataRsp::kResultCodeFieldNumber;
const int IMFilePullDataRsp::kTaskIdFieldNumber;
const int IMFilePullDataRsp::kUserIdFieldNumber;
const int IMFilePullDataRsp::kOffsetFieldNumber;
const int IMFilePullDataRsp::kFileDataFieldNumber;
#endif  // !_MSC_VER

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

void IMFilePullDataRsp::InitAsDefaultInstance() {
}

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

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

IMFilePullDataRsp::~IMFilePullDataRsp() {
  // @@protoc_insertion_point(destructor:IM.File.IMFilePullDataRsp)
  SharedDtor();
}

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

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

IMFilePullDataRsp* IMFilePullDataRsp::default_instance_ = NULL;

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

void IMFilePullDataRsp::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<IMFilePullDataRsp*>(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_(result_code_, user_id_);
    if (has_task_id()) {
      if (task_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        task_id_->clear();
      }
    }
    offset_ = 0u;
    if (has_file_data()) {
      if (file_data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        file_data_->clear();
      }
    }
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

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

bool IMFilePullDataRsp::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.File.IMFilePullDataRsp)
  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->ExpectTag(18)) goto parse_task_id;
        break;
      }

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

      // required uint32 user_id = 3;
      case 3: {
        if (tag == 24) {
         parse_user_id:
          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(32)) goto parse_offset;
        break;
      }

      // required uint32 offset = 4;
      case 4: {
        if (tag == 32) {
         parse_offset:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &offset_)));
          set_has_offset();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(42)) goto parse_file_data;
        break;
      }

      // required bytes file_data = 5;
      case 5: {
        if (tag == 42) {
         parse_file_data:
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_file_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.File.IMFilePullDataRsp)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:IM.File.IMFilePullDataRsp)
  return false;
#undef DO_
}

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

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

  // required uint32 user_id = 3;
  if (has_user_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->user_id(), output);
  }

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

  // required bytes file_data = 5;
  if (has_file_data()) {
    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
      5, this->file_data(), output);
  }

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

int IMFilePullDataRsp::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());
    }

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

    // required uint32 user_id = 3;
    if (has_user_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->user_id());
    }

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

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

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

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

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

void IMFilePullDataRsp::MergeFrom(const IMFilePullDataRsp& 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_task_id()) {
      set_task_id(from.task_id());
    }
    if (from.has_user_id()) {
      set_user_id(from.user_id());
    }
    if (from.has_offset()) {
      set_offset(from.offset());
    }
    if (from.has_file_data()) {
      set_file_data(from.file_data());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

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

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

  return true;
}

void IMFilePullDataRsp::Swap(IMFilePullDataRsp* other) {
  if (other != this) {
    std::swap(result_code_, other->result_code_);
    std::swap(task_id_, other->task_id_);
    std::swap(user_id_, other->user_id_);
    std::swap(offset_, other->offset_);
    std::swap(file_data_, other->file_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 IMFilePullDataRsp::GetTypeName() const {
  return "IM.File.IMFilePullDataRsp";
}


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

#ifndef _MSC_VER
const int IMFileReq::kFromUserIdFieldNumber;
const int IMFileReq::kToUserIdFieldNumber;
const int IMFileReq::kFileNameFieldNumber;
const int IMFileReq::kFileSizeFieldNumber;
const int IMFileReq::kTransModeFieldNumber;
#endif  // !_MSC_VER

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

void IMFileReq::InitAsDefaultInstance() {
}

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

void IMFileReq::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  from_user_id_ = 0u;
  to_user_id_ = 0u;
  file_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  file_size_ = 0u;
  trans_mode_ = 1;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

IMFileReq::~IMFileReq() {
  // @@protoc_insertion_point(destructor:IM.File.IMFileReq)
  SharedDtor();
}

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

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

IMFileReq* IMFileReq::default_instance_ = NULL;

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

void IMFileReq::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<IMFileReq*>(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_(from_user_id_, to_user_id_);
    if (has_file_name()) {
      if (file_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        file_name_->clear();
      }
    }
    file_size_ = 0u;
    trans_mode_ = 1;
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

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

bool IMFileReq::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.File.IMFileReq)
  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 from_user_id = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &from_user_id_)));
          set_has_from_user_id();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_to_user_id;
        break;
      }

      // required uint32 to_user_id = 2;
      case 2: {
        if (tag == 16) {
         parse_to_user_id:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &to_user_id_)));
          set_has_to_user_id();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_file_name;
        break;
      }

      // required string file_name = 3;
      case 3: {
        if (tag == 26) {
         parse_file_name:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_file_name()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(32)) goto parse_file_size;
        break;
      }

      // required uint32 file_size = 4;
      case 4: {
        if (tag == 32) {
         parse_file_size:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &file_size_)));
          set_has_file_size();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(40)) goto parse_trans_mode;
        break;
      }

      // required .IM.BaseDefine.TransferFileType trans_mode = 5;
      case 5: {
        if (tag == 40) {
         parse_trans_mode:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::IM::BaseDefine::TransferFileType_IsValid(value)) {
            set_trans_mode(static_cast< ::IM::BaseDefine::TransferFileType >(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.File.IMFileReq)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:IM.File.IMFileReq)
  return false;
#undef DO_
}

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

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

  // required string file_name = 3;
  if (has_file_name()) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      3, this->file_name(), output);
  }

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

  // required .IM.BaseDefine.TransferFileType trans_mode = 5;
  if (has_trans_mode()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      5, this->trans_mode(), output);
  }

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

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

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

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

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

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

    // required .IM.BaseDefine.TransferFileType trans_mode = 5;
    if (has_trans_mode()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->trans_mode());
    }

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

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

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

void IMFileReq::MergeFrom(const IMFileReq& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_from_user_id()) {
      set_from_user_id(from.from_user_id());
    }
    if (from.has_to_user_id()) {
      set_to_user_id(from.to_user_id());
    }
    if (from.has_file_name()) {
      set_file_name(from.file_name());
    }
    if (from.has_file_size()) {
      set_file_size(from.file_size());
    }
    if (from.has_trans_mode()) {
      set_trans_mode(from.trans_mode());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

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

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

  return true;
}

void IMFileReq::Swap(IMFileReq* other) {
  if (other != this) {
    std::swap(from_user_id_, other->from_user_id_);
    std::swap(to_user_id_, other->to_user_id_);
    std::swap(file_name_, other->file_name_);
    std::swap(file_size_, other->file_size_);
    std::swap(trans_mode_, other->trans_mode_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string IMFileReq::GetTypeName() const {
  return "IM.File.IMFileReq";
}


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

#ifndef _MSC_VER
const int IMFileRsp::kResultCodeFieldNumber;
const int IMFileRsp::kFromUserIdFieldNumber;
const int IMFileRsp::kToUserIdFieldNumber;
const int IMFileRsp::kFileNameFieldNumber;
const int IMFileRsp::kTaskIdFieldNumber;
const int IMFileRsp::kIpAddrListFieldNumber;
const int IMFileRsp::kTransModeFieldNumber;
#endif  // !_MSC_VER

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

void IMFileRsp::InitAsDefaultInstance() {
}

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

void IMFileRsp::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  result_code_ = 0u;
  from_user_id_ = 0u;
  to_user_id_ = 0u;
  file_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  task_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  trans_mode_ = 1;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

IMFileRsp::~IMFileRsp() {
  // @@protoc_insertion_point(destructor:IM.File.IMFileRsp)
  SharedDtor();
}

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

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

IMFileRsp* IMFileRsp::default_instance_ = NULL;

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

void IMFileRsp::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<IMFileRsp*>(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] & 95) {
    ZR_(result_code_, from_user_id_);
    to_user_id_ = 0u;
    if (has_file_name()) {
      if (file_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        file_name_->clear();
      }
    }
    if (has_task_id()) {
      if (task_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        task_id_->clear();
      }
    }
    trans_mode_ = 1;
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

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

bool IMFileRsp::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.File.IMFileRsp)
  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->ExpectTag(16)) goto parse_from_user_id;
        break;
      }

      // required uint32 from_user_id = 2;
      case 2: {
        if (tag == 16) {
         parse_from_user_id:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &from_user_id_)));
          set_has_from_user_id();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_to_user_id;
        break;
      }

      // required uint32 to_user_id = 3;
      case 3: {
        if (tag == 24) {
         parse_to_user_id:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &to_user_id_)));
          set_has_to_user_id();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(34)) goto parse_file_name;
        break;
      }

      // required string file_name = 4;
      case 4: {
        if (tag == 34) {
         parse_file_name:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_file_name()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(42)) goto parse_task_id;
        break;
      }

      // required string task_id = 5;
      case 5: {
        if (tag == 42) {
         parse_task_id:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_task_id()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(50)) goto parse_ip_addr_list;
        break;
      }

      // repeated .IM.BaseDefine.IpAddr ip_addr_list = 6;
      case 6: {
        if (tag == 50) {
         parse_ip_addr_list:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_ip_addr_list()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(50)) goto parse_ip_addr_list;
        if (input->ExpectTag(56)) goto parse_trans_mode;
        break;
      }

      // required .IM.BaseDefine.TransferFileType trans_mode = 7;
      case 7: {
        if (tag == 56) {
         parse_trans_mode:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::IM::BaseDefine::TransferFileType_IsValid(value)) {
            set_trans_mode(static_cast< ::IM::BaseDefine::TransferFileType >(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.File.IMFileRsp)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:IM.File.IMFileRsp)
  return false;
#undef DO_
}

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

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

  // required uint32 to_user_id = 3;
  if (has_to_user_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->to_user_id(), output);
  }

  // required string file_name = 4;
  if (has_file_name()) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      4, this->file_name(), output);
  }

  // required string task_id = 5;
  if (has_task_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      5, this->task_id(), output);
  }

  // repeated .IM.BaseDefine.IpAddr ip_addr_list = 6;
  for (int i = 0; i < this->ip_addr_list_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      6, this->ip_addr_list(i), output);
  }

  // required .IM.BaseDefine.TransferFileType trans_mode = 7;
  if (has_trans_mode()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      7, this->trans_mode(), output);
  }

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

int IMFileRsp::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());
    }

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

    // required uint32 to_user_id = 3;
    if (has_to_user_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->to_user_id());
    }

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

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

    // required .IM.BaseDefine.TransferFileType trans_mode = 7;
    if (has_trans_mode()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->trans_mode());
    }

  }
  // repeated .IM.BaseDefine.IpAddr ip_addr_list = 6;
  total_size += 1 * this->ip_addr_list_size();
  for (int i = 0; i < this->ip_addr_list_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->ip_addr_list(i));
  }

  total_size += unknown_fields().size();

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

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

void IMFileRsp::MergeFrom(const IMFileRsp& from) {
  GOOGLE_CHECK_NE(&from, this);
  ip_addr_list_.MergeFrom(from.ip_addr_list_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_result_code()) {
      set_result_code(from.result_code());
    }
    if (from.has_from_user_id()) {
      set_from_user_id(from.from_user_id());
    }
    if (from.has_to_user_id()) {
      set_to_user_id(from.to_user_id());
    }
    if (from.has_file_name()) {
      set_file_name(from.file_name());
    }
    if (from.has_task_id()) {
      set_task_id(from.task_id());
    }
    if (from.has_trans_mode()) {
      set_trans_mode(from.trans_mode());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

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

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

  if (!::google::protobuf::internal::AllAreInitialized(this->ip_addr_list())) return false;
  return true;
}

void IMFileRsp::Swap(IMFileRsp* other) {
  if (other != this) {
    std::swap(result_code_, other->result_code_);
    std::swap(from_user_id_, other->from_user_id_);
    std::swap(to_user_id_, other->to_user_id_);
    std::swap(file_name_, other->file_name_);
    std::swap(task_id_, other->task_id_);
    ip_addr_list_.Swap(&other->ip_addr_list_);
    std::swap(trans_mode_, other->trans_mode_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string IMFileRsp::GetTypeName() const {
  return "IM.File.IMFileRsp";
}


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

#ifndef _MSC_VER
const int IMFileNotify::kFromUserIdFieldNumber;
const int IMFileNotify::kToUserIdFieldNumber;
const int IMFileNotify::kFileNameFieldNumber;
const int IMFileNotify::kFileSizeFieldNumber;
const int IMFileNotify::kTaskIdFieldNumber;
const int IMFileNotify::kIpAddrListFieldNumber;
const int IMFileNotify::kTransModeFieldNumber;
const int IMFileNotify::kOfflineReadyFieldNumber;
#endif  // !_MSC_VER

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

void IMFileNotify::InitAsDefaultInstance() {
}

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

void IMFileNotify::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  from_user_id_ = 0u;
  to_user_id_ = 0u;
  file_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  file_size_ = 0u;
  task_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  trans_mode_ = 1;
  offline_ready_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

IMFileNotify::~IMFileNotify() {
  // @@protoc_insertion_point(destructor:IM.File.IMFileNotify)
  SharedDtor();
}

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

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

IMFileNotify* IMFileNotify::default_instance_ = NULL;

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

void IMFileNotify::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<IMFileNotify*>(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] & 223) {
    ZR_(from_user_id_, to_user_id_);
    if (has_file_name()) {
      if (file_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        file_name_->clear();
      }
    }
    file_size_ = 0u;
    if (has_task_id()) {
      if (task_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        task_id_->clear();
      }
    }
    trans_mode_ = 1;
    offline_ready_ = 0u;
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

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

bool IMFileNotify::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.File.IMFileNotify)
  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 from_user_id = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &from_user_id_)));
          set_has_from_user_id();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_to_user_id;
        break;
      }

      // required uint32 to_user_id = 2;
      case 2: {
        if (tag == 16) {
         parse_to_user_id:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &to_user_id_)));
          set_has_to_user_id();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_file_name;
        break;
      }

      // required string file_name = 3;
      case 3: {
        if (tag == 26) {
         parse_file_name:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_file_name()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(32)) goto parse_file_size;
        break;
      }

      // required uint32 file_size = 4;
      case 4: {
        if (tag == 32) {
         parse_file_size:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &file_size_)));
          set_has_file_size();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(42)) goto parse_task_id;
        break;
      }

      // required string task_id = 5;
      case 5: {
        if (tag == 42) {
         parse_task_id:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_task_id()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(50)) goto parse_ip_addr_list;
        break;
      }

      // repeated .IM.BaseDefine.IpAddr ip_addr_list = 6;
      case 6: {
        if (tag == 50) {
         parse_ip_addr_list:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_ip_addr_list()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(50)) goto parse_ip_addr_list;
        if (input->ExpectTag(56)) goto parse_trans_mode;
        break;
      }

      // required .IM.BaseDefine.TransferFileType trans_mode = 7;
      case 7: {
        if (tag == 56) {
         parse_trans_mode:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::IM::BaseDefine::TransferFileType_IsValid(value)) {
            set_trans_mode(static_cast< ::IM::BaseDefine::TransferFileType >(value));
          } else {
            unknown_fields_stream.WriteVarint32(tag);
            unknown_fields_stream.WriteVarint32(value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(64)) goto parse_offline_ready;
        break;
      }

      // required uint32 offline_ready = 8;
      case 8: {
        if (tag == 64) {
         parse_offline_ready:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &offline_ready_)));
          set_has_offline_ready();
        } 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.File.IMFileNotify)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:IM.File.IMFileNotify)
  return false;
#undef DO_
}

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

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

  // required string file_name = 3;
  if (has_file_name()) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      3, this->file_name(), output);
  }

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

  // required string task_id = 5;
  if (has_task_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      5, this->task_id(), output);
  }

  // repeated .IM.BaseDefine.IpAddr ip_addr_list = 6;
  for (int i = 0; i < this->ip_addr_list_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      6, this->ip_addr_list(i), output);
  }

  // required .IM.BaseDefine.TransferFileType trans_mode = 7;
  if (has_trans_mode()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      7, this->trans_mode(), output);
  }

  // required uint32 offline_ready = 8;
  if (has_offline_ready()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(8, this->offline_ready(), output);
  }

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

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

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

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

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

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

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

    // required .IM.BaseDefine.TransferFileType trans_mode = 7;
    if (has_trans_mode()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->trans_mode());
    }

    // required uint32 offline_ready = 8;
    if (has_offline_ready()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->offline_ready());
    }

  }
  // repeated .IM.BaseDefine.IpAddr ip_addr_list = 6;
  total_size += 1 * this->ip_addr_list_size();
  for (int i = 0; i < this->ip_addr_list_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->ip_addr_list(i));
  }

  total_size += unknown_fields().size();

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

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

void IMFileNotify::MergeFrom(const IMFileNotify& from) {
  GOOGLE_CHECK_NE(&from, this);
  ip_addr_list_.MergeFrom(from.ip_addr_list_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_from_user_id()) {
      set_from_user_id(from.from_user_id());
    }
    if (from.has_to_user_id()) {
      set_to_user_id(from.to_user_id());
    }
    if (from.has_file_name()) {
      set_file_name(from.file_name());
    }
    if (from.has_file_size()) {
      set_file_size(from.file_size());
    }
    if (from.has_task_id()) {
      set_task_id(from.task_id());
    }
    if (from.has_trans_mode()) {
      set_trans_mode(from.trans_mode());
    }
    if (from.has_offline_ready()) {
      set_offline_ready(from.offline_ready());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

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

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

  if (!::google::protobuf::internal::AllAreInitialized(this->ip_addr_list())) return false;
  return true;
}

void IMFileNotify::Swap(IMFileNotify* other) {
  if (other != this) {
    std::swap(from_user_id_, other->from_user_id_);
    std::swap(to_user_id_, other->to_user_id_);
    std::swap(file_name_, other->file_name_);
    std::swap(file_size_, other->file_size_);
    std::swap(task_id_, other->task_id_);
    ip_addr_list_.Swap(&other->ip_addr_list_);
    std::swap(trans_mode_, other->trans_mode_);
    std::swap(offline_ready_, other->offline_ready_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string IMFileNotify::GetTypeName() const {
  return "IM.File.IMFileNotify";
}


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

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

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

void IMFileHasOfflineReq::InitAsDefaultInstance() {
}

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

void IMFileHasOfflineReq::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_));
}

IMFileHasOfflineReq::~IMFileHasOfflineReq() {
  // @@protoc_insertion_point(destructor:IM.File.IMFileHasOfflineReq)
  SharedDtor();
}

void IMFileHasOfflineReq::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 IMFileHasOfflineReq::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const IMFileHasOfflineReq& IMFileHasOfflineReq::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_IM_2eFile_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_IM_2eFile_2eproto();
#endif
  return *default_instance_;
}

IMFileHasOfflineReq* IMFileHasOfflineReq::default_instance_ = NULL;

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

void IMFileHasOfflineReq::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 IMFileHasOfflineReq::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.File.IMFileHasOfflineReq)
  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.File.IMFileHasOfflineReq)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:IM.File.IMFileHasOfflineReq)
  return false;
#undef DO_
}

void IMFileHasOfflineReq::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:IM.File.IMFileHasOfflineReq)
  // 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.File.IMFileHasOfflineReq)
}

int IMFileHasOfflineReq::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 IMFileHasOfflineReq::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const IMFileHasOfflineReq*>(&from));
}

void IMFileHasOfflineReq::MergeFrom(const IMFileHasOfflineReq& 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 IMFileHasOfflineReq::CopyFrom(const IMFileHasOfflineReq& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

  return true;
}

void IMFileHasOfflineReq::Swap(IMFileHasOfflineReq* 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 IMFileHasOfflineReq::GetTypeName() const {
  return "IM.File.IMFileHasOfflineReq";
}


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

#ifndef _MSC_VER
const int IMFileHasOfflineRsp::kUserIdFieldNumber;
const int IMFileHasOfflineRsp::kOfflineFileListFieldNumber;
const int IMFileHasOfflineRsp::kIpAddrListFieldNumber;
const int IMFileHasOfflineRsp::kAttachDataFieldNumber;
#endif  // !_MSC_VER

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

void IMFileHasOfflineRsp::InitAsDefaultInstance() {
}

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

void IMFileHasOfflineRsp::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_));
}

IMFileHasOfflineRsp::~IMFileHasOfflineRsp() {
  // @@protoc_insertion_point(destructor:IM.File.IMFileHasOfflineRsp)
  SharedDtor();
}

void IMFileHasOfflineRsp::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 IMFileHasOfflineRsp::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const IMFileHasOfflineRsp& IMFileHasOfflineRsp::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_IM_2eFile_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_IM_2eFile_2eproto();
#endif
  return *default_instance_;
}

IMFileHasOfflineRsp* IMFileHasOfflineRsp::default_instance_ = NULL;

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

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

bool IMFileHasOfflineRsp::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.File.IMFileHasOfflineRsp)
  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_offline_file_list;
        break;
      }

      // repeated .IM.BaseDefine.OfflineFileInfo offline_file_list = 2;
      case 2: {
        if (tag == 18) {
         parse_offline_file_list:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_offline_file_list()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_offline_file_list;
        if (input->ExpectTag(26)) goto parse_ip_addr_list;
        break;
      }

      // repeated .IM.BaseDefine.IpAddr ip_addr_list = 3;
      case 3: {
        if (tag == 26) {
         parse_ip_addr_list:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_ip_addr_list()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_ip_addr_list;
        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.File.IMFileHasOfflineRsp)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:IM.File.IMFileHasOfflineRsp)
  return false;
#undef DO_
}

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

  // repeated .IM.BaseDefine.OfflineFileInfo offline_file_list = 2;
  for (int i = 0; i < this->offline_file_list_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      2, this->offline_file_list(i), output);
  }

  // repeated .IM.BaseDefine.IpAddr ip_addr_list = 3;
  for (int i = 0; i < this->ip_addr_list_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      3, this->ip_addr_list(i), 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.File.IMFileHasOfflineRsp)
}

int IMFileHasOfflineRsp::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());
    }

  }
  // repeated .IM.BaseDefine.OfflineFileInfo offline_file_list = 2;
  total_size += 1 * this->offline_file_list_size();
  for (int i = 0; i < this->offline_file_list_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->offline_file_list(i));
  }

  // repeated .IM.BaseDefine.IpAddr ip_addr_list = 3;
  total_size += 1 * this->ip_addr_list_size();
  for (int i = 0; i < this->ip_addr_list_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->ip_addr_list(i));
  }

  total_size += unknown_fields().size();

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

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

void IMFileHasOfflineRsp::MergeFrom(const IMFileHasOfflineRsp& from) {
  GOOGLE_CHECK_NE(&from, this);
  offline_file_list_.MergeFrom(from.offline_file_list_);
  ip_addr_list_.MergeFrom(from.ip_addr_list_);
  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 IMFileHasOfflineRsp::CopyFrom(const IMFileHasOfflineRsp& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

  if (!::google::protobuf::internal::AllAreInitialized(this->offline_file_list())) return false;
  if (!::google::protobuf::internal::AllAreInitialized(this->ip_addr_list())) return false;
  return true;
}

void IMFileHasOfflineRsp::Swap(IMFileHasOfflineRsp* other) {
  if (other != this) {
    std::swap(user_id_, other->user_id_);
    offline_file_list_.Swap(&other->offline_file_list_);
    ip_addr_list_.Swap(&other->ip_addr_list_);
    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 IMFileHasOfflineRsp::GetTypeName() const {
  return "IM.File.IMFileHasOfflineRsp";
}


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

#ifndef _MSC_VER
const int IMFileAddOfflineReq::kFromUserIdFieldNumber;
const int IMFileAddOfflineReq::kToUserIdFieldNumber;
const int IMFileAddOfflineReq::kTaskIdFieldNumber;
const int IMFileAddOfflineReq::kFileNameFieldNumber;
const int IMFileAddOfflineReq::kFileSizeFieldNumber;
#endif  // !_MSC_VER

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

void IMFileAddOfflineReq::InitAsDefaultInstance() {
}

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

void IMFileAddOfflineReq::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  from_user_id_ = 0u;
  to_user_id_ = 0u;
  task_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  file_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  file_size_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

IMFileAddOfflineReq::~IMFileAddOfflineReq() {
  // @@protoc_insertion_point(destructor:IM.File.IMFileAddOfflineReq)
  SharedDtor();
}

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

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

IMFileAddOfflineReq* IMFileAddOfflineReq::default_instance_ = NULL;

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

void IMFileAddOfflineReq::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<IMFileAddOfflineReq*>(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_(from_user_id_, to_user_id_);
    if (has_task_id()) {
      if (task_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        task_id_->clear();
      }
    }
    if (has_file_name()) {
      if (file_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        file_name_->clear();
      }
    }
    file_size_ = 0u;
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

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

bool IMFileAddOfflineReq::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.File.IMFileAddOfflineReq)
  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 from_user_id = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &from_user_id_)));
          set_has_from_user_id();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_to_user_id;
        break;
      }

      // required uint32 to_user_id = 2;
      case 2: {
        if (tag == 16) {
         parse_to_user_id:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &to_user_id_)));
          set_has_to_user_id();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_task_id;
        break;
      }

      // required string task_id = 3;
      case 3: {
        if (tag == 26) {
         parse_task_id:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_task_id()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(34)) goto parse_file_name;
        break;
      }

      // required string file_name = 4;
      case 4: {
        if (tag == 34) {
         parse_file_name:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_file_name()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(40)) goto parse_file_size;
        break;
      }

      // required uint32 file_size = 5;
      case 5: {
        if (tag == 40) {
         parse_file_size:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &file_size_)));
          set_has_file_size();
        } 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.File.IMFileAddOfflineReq)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:IM.File.IMFileAddOfflineReq)
  return false;
#undef DO_
}

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

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

  // required string task_id = 3;
  if (has_task_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      3, this->task_id(), output);
  }

  // required string file_name = 4;
  if (has_file_name()) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      4, this->file_name(), output);
  }

  // required uint32 file_size = 5;
  if (has_file_size()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(5, this->file_size(), output);
  }

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

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

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

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

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

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

    // required uint32 file_size = 5;
    if (has_file_size()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->file_size());
    }

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

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

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

void IMFileAddOfflineReq::MergeFrom(const IMFileAddOfflineReq& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_from_user_id()) {
      set_from_user_id(from.from_user_id());
    }
    if (from.has_to_user_id()) {
      set_to_user_id(from.to_user_id());
    }
    if (from.has_task_id()) {
      set_task_id(from.task_id());
    }
    if (from.has_file_name()) {
      set_file_name(from.file_name());
    }
    if (from.has_file_size()) {
      set_file_size(from.file_size());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

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

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

  return true;
}

void IMFileAddOfflineReq::Swap(IMFileAddOfflineReq* other) {
  if (other != this) {
    std::swap(from_user_id_, other->from_user_id_);
    std::swap(to_user_id_, other->to_user_id_);
    std::swap(task_id_, other->task_id_);
    std::swap(file_name_, other->file_name_);
    std::swap(file_size_, other->file_size_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string IMFileAddOfflineReq::GetTypeName() const {
  return "IM.File.IMFileAddOfflineReq";
}


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

#ifndef _MSC_VER
const int IMFileDelOfflineReq::kFromUserIdFieldNumber;
const int IMFileDelOfflineReq::kToUserIdFieldNumber;
const int IMFileDelOfflineReq::kTaskIdFieldNumber;
#endif  // !_MSC_VER

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

void IMFileDelOfflineReq::InitAsDefaultInstance() {
}

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

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

IMFileDelOfflineReq::~IMFileDelOfflineReq() {
  // @@protoc_insertion_point(destructor:IM.File.IMFileDelOfflineReq)
  SharedDtor();
}

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

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

IMFileDelOfflineReq* IMFileDelOfflineReq::default_instance_ = NULL;

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

void IMFileDelOfflineReq::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<IMFileDelOfflineReq*>(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_(from_user_id_, to_user_id_);
    if (has_task_id()) {
      if (task_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        task_id_->clear();
      }
    }
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

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

bool IMFileDelOfflineReq::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.File.IMFileDelOfflineReq)
  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 from_user_id = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &from_user_id_)));
          set_has_from_user_id();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_to_user_id;
        break;
      }

      // required uint32 to_user_id = 2;
      case 2: {
        if (tag == 16) {
         parse_to_user_id:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &to_user_id_)));
          set_has_to_user_id();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_task_id;
        break;
      }

      // required string task_id = 3;
      case 3: {
        if (tag == 26) {
         parse_task_id:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_task_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.File.IMFileDelOfflineReq)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:IM.File.IMFileDelOfflineReq)
  return false;
#undef DO_
}

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

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

  // required string task_id = 3;
  if (has_task_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      3, this->task_id(), output);
  }

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

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

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

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

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

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

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

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

void IMFileDelOfflineReq::MergeFrom(const IMFileDelOfflineReq& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_from_user_id()) {
      set_from_user_id(from.from_user_id());
    }
    if (from.has_to_user_id()) {
      set_to_user_id(from.to_user_id());
    }
    if (from.has_task_id()) {
      set_task_id(from.task_id());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

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

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

  return true;
}

void IMFileDelOfflineReq::Swap(IMFileDelOfflineReq* other) {
  if (other != this) {
    std::swap(from_user_id_, other->from_user_id_);
    std::swap(to_user_id_, other->to_user_id_);
    std::swap(task_id_, other->task_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 IMFileDelOfflineReq::GetTypeName() const {
  return "IM.File.IMFileDelOfflineReq";
}


// @@protoc_insertion_point(namespace_scope)

}  // namespace File
}  // namespace IM

// @@protoc_insertion_point(global_scope)
