text: // Generated by the protocol buffer compiler.  DO NOT EDIT!
  #include "cbase.h"
  #define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
  #include "gcsdk_gcmessages.pb.h"
  
  #if _MSC_VER >= 1300
  #ifndef _PS3
  #pragma warning(push)
  #pragma warning(disable : 4530)	// warning C4530: C++ exception handler used, but unwind semantics are not enabled. Specify /EHsc (disabled due to std headers having exception syntax)
  #pragma warning(disable : 4244)	// warning C4244:  warning C4244: '=' : conversion from '__w64 int' to 'int', possible loss of data
  #pragma warning(disable : 4267)	// warning C4267: 'argument' : conversion from 'size_t' to 'int', possible loss of data
  #pragma warning(disable : 4125)	// warning C4125: decimal digit terminates octal escape sequence
  #pragma warning(disable : 4127)	// warning C4127: conditional expression is constant
  #pragma warning(disable : 4100)	// warning C4100: 'op' : unreferenced formal parameter
  #endif // _PS3
  #endif // _MSC_VER
  #if _GNUC
  #ifndef _PS3
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wshadow"
  #endif // _PS3
  #endif // _GNUC
  
  #include <google/protobuf/stubs/once.h>
  #include <google/protobuf/io/coded_stream.h>
  #include <google/protobuf/wire_format_lite_inl.h>
  #include <google/protobuf/descriptor.h>
  #include <google/protobuf/reflection_ops.h>
  #include <google/protobuf/wire_format.h>
  // @@protoc_insertion_point(includes)
  
  namespace {
  
  const ::google::protobuf::Descriptor* CMsgSOIDOwner_descriptor_ = NULL;
  const ::google::protobuf::internal::GeneratedMessageReflection*
    CMsgSOIDOwner_reflection_ = NULL;
  const ::google::protobuf::Descriptor* CMsgSOSingleObject_descriptor_ = NULL;
  const ::google::protobuf::internal::GeneratedMessageReflection*
    CMsgSOSingleObject_reflection_ = NULL;
  const ::google::protobuf::Descriptor* CMsgSOMultipleObjects_descriptor_ = NULL;
  const ::google::protobuf::internal::GeneratedMessageReflection*
    CMsgSOMultipleObjects_reflection_ = NULL;
  const ::google::protobuf::Descriptor* CMsgSOMultipleObjects_SingleObject_descriptor_ = NULL;
  const ::google::protobuf::internal::GeneratedMessageReflection*
    CMsgSOMultipleObjects_SingleObject_reflection_ = NULL;
  const ::google::protobuf::Descriptor* CMsgSOCacheSubscribed_descriptor_ = NULL;
  const ::google::protobuf::internal::GeneratedMessageReflection*
    CMsgSOCacheSubscribed_reflection_ = NULL;
  const ::google::protobuf::Descriptor* CMsgSOCacheSubscribed_SubscribedType_descriptor_ = NULL;
  const ::google::protobuf::internal::GeneratedMessageReflection*
    CMsgSOCacheSubscribed_SubscribedType_reflection_ = NULL;
  const ::google::protobuf::Descriptor* CMsgSOCacheSubscribedUpToDate_descriptor_ = NULL;
  const ::google::protobuf::internal::GeneratedMessageReflection*
    CMsgSOCacheSubscribedUpToDate_reflection_ = NULL;
  const ::google::protobuf::Descriptor* CMsgSOCacheUnsubscribed_descriptor_ = NULL;
  const ::google::protobuf::internal::GeneratedMessageReflection*
    CMsgSOCacheUnsubscribed_reflection_ = NULL;
  const ::google::protobuf::Descriptor* CMsgSOCacheSubscriptionCheck_descriptor_ = NULL;
  const ::google::protobuf::internal::GeneratedMessageReflection*
    CMsgSOCacheSubscriptionCheck_reflection_ = NULL;
  const ::google::protobuf::Descriptor* CMsgSOCacheSubscriptionRefresh_descriptor_ = NULL;
  const ::google::protobuf::internal::GeneratedMessageReflection*
    CMsgSOCacheSubscriptionRefresh_reflection_ = NULL;
  const ::google::protobuf::Descriptor* CMsgSOCacheVersion_descriptor_ = NULL;
  const ::google::protobuf::internal::GeneratedMessageReflection*
    CMsgSOCacheVersion_reflection_ = NULL;
  const ::google::protobuf::Descriptor* CMsgGCMultiplexMessage_descriptor_ = NULL;
  const ::google::protobuf::internal::GeneratedMessageReflection*
    CMsgGCMultiplexMessage_reflection_ = NULL;
  const ::google::protobuf::Descriptor* CGCToGCMsgMasterAck_descriptor_ = NULL;
  const ::google::protobuf::internal::GeneratedMessageReflection*
    CGCToGCMsgMasterAck_reflection_ = NULL;
  const ::google::protobuf::Descriptor* CGCToGCMsgMasterAck_Response_descriptor_ = NULL;
  const ::google::protobuf::internal::GeneratedMessageReflection*
    CGCToGCMsgMasterAck_Response_reflection_ = NULL;
  const ::google::protobuf::Descriptor* CGCToGCMsgMasterStartupComplete_descriptor_ = NULL;
  const ::google::protobuf::internal::GeneratedMessageReflection*
    CGCToGCMsgMasterStartupComplete_reflection_ = NULL;
  const ::google::protobuf::Descriptor* CGCToGCMsgMasterStartupComplete_GCInfo_descriptor_ = NULL;
  const ::google::protobuf::internal::GeneratedMessageReflection*
    CGCToGCMsgMasterStartupComplete_GCInfo_reflection_ = NULL;
  const ::google::protobuf::Descriptor* CGCToGCMsgRouted_descriptor_ = NULL;
  const ::google::protobuf::internal::GeneratedMessageReflection*
    CGCToGCMsgRouted_reflection_ = NULL;
  const ::google::protobuf::Descriptor* CGCToGCMsgRoutedReply_descriptor_ = NULL;
  const ::google::protobuf::internal::GeneratedMessageReflection*
    CGCToGCMsgRoutedReply_reflection_ = NULL;
  const ::google::protobuf::Descriptor* CMsgGCUpdateSubGCSessionInfo_descriptor_ = NULL;
  const ::google::protobuf::internal::GeneratedMessageReflection*
    CMsgGCUpdateSubGCSessionInfo_reflection_ = NULL;
  const ::google::protobuf::Descriptor* CMsgGCUpdateSubGCSessionInfo_CMsgUpdate_descriptor_ = NULL;
  const ::google::protobuf::internal::GeneratedMessageReflection*
    CMsgGCUpdateSubGCSessionInfo_CMsgUpdate_reflection_ = NULL;
  const ::google::protobuf::Descriptor* CMsgGCRequestSubGCSessionInfo_descriptor_ = NULL;
  const ::google::protobuf::internal::GeneratedMessageReflection*
    CMsgGCRequestSubGCSessionInfo_reflection_ = NULL;
  const ::google::protobuf::Descriptor* CMsgGCRequestSubGCSessionInfoResponse_descriptor_ = NULL;
  const ::google::protobuf::internal::GeneratedMessageReflection*
    CMsgGCRequestSubGCSessionInfoResponse_reflection_ = NULL;
  const ::google::protobuf::Descriptor* CMsgGCToGCIncrementRecruitmentLevel_descriptor_ = NULL;
  const ::google::protobuf::internal::GeneratedMessageReflection*
    CMsgGCToGCIncrementRecruitmentLevel_reflection_ = NULL;
  const ::google::protobuf::Descriptor* CMsgSOCacheHaveVersion_descriptor_ = NULL;
  const ::google::protobuf::internal::GeneratedMessageReflection*
    CMsgSOCacheHaveVersion_reflection_ = NULL;
  const ::google::protobuf::Descriptor* CMsgConnectionStatus_descriptor_ = NULL;
  const ::google::protobuf::internal::GeneratedMessageReflection*
    CMsgConnectionStatus_reflection_ = NULL;
  const ::google::protobuf::Descriptor* CMsgGCToGCSOCacheSubscribe_descriptor_ = NULL;
  const ::google::protobuf::internal::GeneratedMessageReflection*
    CMsgGCToGCSOCacheSubscribe_reflection_ = NULL;
  const ::google::protobuf::Descriptor* CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions_descriptor_ = NULL;
  const ::google::protobuf::internal::GeneratedMessageReflection*
    CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions_reflection_ = NULL;
  const ::google::protobuf::Descriptor* CMsgGCToGCSOCacheUnsubscribe_descriptor_ = NULL;
  const ::google::protobuf::internal::GeneratedMessageReflection*
    CMsgGCToGCSOCacheUnsubscribe_reflection_ = NULL;
  const ::google::protobuf::Descriptor* CMsgGCClientPing_descriptor_ = NULL;
  const ::google::protobuf::internal::GeneratedMessageReflection*
    CMsgGCClientPing_reflection_ = NULL;
  const ::google::protobuf::EnumDescriptor* PartnerAccountType_descriptor_ = NULL;
  const ::google::protobuf::EnumDescriptor* GCConnectionStatus_descriptor_ = NULL;
  
  }  // namespace
  
  
  void protobuf_AssignDesc_gcsdk_5fgcmessages_2eproto() {
    protobuf_AddDesc_gcsdk_5fgcmessages_2eproto();
    const ::google::protobuf::FileDescriptor* file =
      ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
        "gcsdk_gcmessages.proto");
    GOOGLE_CHECK(file != NULL);
    CMsgSOIDOwner_descriptor_ = file->message_type(0);
    static const int CMsgSOIDOwner_offsets_[2] = {
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgSOIDOwner, type_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgSOIDOwner, id_),
    };
    CMsgSOIDOwner_reflection_ =
      new ::google::protobuf::internal::GeneratedMessageReflection(
        CMsgSOIDOwner_descriptor_,
        CMsgSOIDOwner::default_instance_,
        CMsgSOIDOwner_offsets_,
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgSOIDOwner, _has_bits_[0]),
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgSOIDOwner, _unknown_fields_),
        -1,
        ::google::protobuf::DescriptorPool::generated_pool(),
        ::google::protobuf::MessageFactory::generated_factory(),
        sizeof(CMsgSOIDOwner));
    CMsgSOSingleObject_descriptor_ = file->message_type(1);
    static const int CMsgSOSingleObject_offsets_[6] = {
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgSOSingleObject, owner_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgSOSingleObject, type_id_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgSOSingleObject, object_data_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgSOSingleObject, version_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgSOSingleObject, owner_soid_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgSOSingleObject, service_id_),
    };
    CMsgSOSingleObject_reflection_ =
      new ::google::protobuf::internal::GeneratedMessageReflection(
        CMsgSOSingleObject_descriptor_,
        CMsgSOSingleObject::default_instance_,
        CMsgSOSingleObject_offsets_,
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgSOSingleObject, _has_bits_[0]),
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgSOSingleObject, _unknown_fields_),
        -1,
        ::google::protobuf::DescriptorPool::generated_pool(),
        ::google::protobuf::MessageFactory::generated_factory(),
        sizeof(CMsgSOSingleObject));
    CMsgSOMultipleObjects_descriptor_ = file->message_type(2);
    static const int CMsgSOMultipleObjects_offsets_[5] = {
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgSOMultipleObjects, owner_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgSOMultipleObjects, objects_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgSOMultipleObjects, version_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgSOMultipleObjects, owner_soid_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgSOMultipleObjects, service_id_),
    };
    CMsgSOMultipleObjects_reflection_ =
      new ::google::protobuf::internal::GeneratedMessageReflection(
        CMsgSOMultipleObjects_descriptor_,
        CMsgSOMultipleObjects::default_instance_,
        CMsgSOMultipleObjects_offsets_,
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgSOMultipleObjects, _has_bits_[0]),
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgSOMultipleObjects, _unknown_fields_),
        -1,
        ::google::protobuf::DescriptorPool::generated_pool(),
        ::google::protobuf::MessageFactory::generated_factory(),
        sizeof(CMsgSOMultipleObjects));
    CMsgSOMultipleObjects_SingleObject_descriptor_ = CMsgSOMultipleObjects_descriptor_->nested_type(0);
    static const int CMsgSOMultipleObjects_SingleObject_offsets_[2] = {
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgSOMultipleObjects_SingleObject, type_id_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgSOMultipleObjects_SingleObject, object_data_),
    };
    CMsgSOMultipleObjects_SingleObject_reflection_ =
      new ::google::protobuf::internal::GeneratedMessageReflection(
        CMsgSOMultipleObjects_SingleObject_descriptor_,
        CMsgSOMultipleObjects_SingleObject::default_instance_,
        CMsgSOMultipleObjects_SingleObject_offsets_,
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgSOMultipleObjects_SingleObject, _has_bits_[0]),
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgSOMultipleObjects_SingleObject, _unknown_fields_),
        -1,
        ::google::protobuf::DescriptorPool::generated_pool(),
        ::google::protobuf::MessageFactory::generated_factory(),
        sizeof(CMsgSOMultipleObjects_SingleObject));
    CMsgSOCacheSubscribed_descriptor_ = file->message_type(3);
    static const int CMsgSOCacheSubscribed_offsets_[7] = {
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgSOCacheSubscribed, owner_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgSOCacheSubscribed, objects_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgSOCacheSubscribed, version_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgSOCacheSubscribed, owner_soid_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgSOCacheSubscribed, service_id_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgSOCacheSubscribed, service_list_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgSOCacheSubscribed, sync_version_),
    };
    CMsgSOCacheSubscribed_reflection_ =
      new ::google::protobuf::internal::GeneratedMessageReflection(
        CMsgSOCacheSubscribed_descriptor_,
        CMsgSOCacheSubscribed::default_instance_,
        CMsgSOCacheSubscribed_offsets_,
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgSOCacheSubscribed, _has_bits_[0]),
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgSOCacheSubscribed, _unknown_fields_),
        -1,
        ::google::protobuf::DescriptorPool::generated_pool(),
        ::google::protobuf::MessageFactory::generated_factory(),
        sizeof(CMsgSOCacheSubscribed));
    CMsgSOCacheSubscribed_SubscribedType_descriptor_ = CMsgSOCacheSubscribed_descriptor_->nested_type(0);
    static const int CMsgSOCacheSubscribed_SubscribedType_offsets_[2] = {
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgSOCacheSubscribed_SubscribedType, type_id_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgSOCacheSubscribed_SubscribedType, object_data_),
    };
    CMsgSOCacheSubscribed_SubscribedType_reflection_ =
      new ::google::protobuf::internal::GeneratedMessageReflection(
        CMsgSOCacheSubscribed_SubscribedType_descriptor_,
        CMsgSOCacheSubscribed_SubscribedType::default_instance_,
        CMsgSOCacheSubscribed_SubscribedType_offsets_,
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgSOCacheSubscribed_SubscribedType, _has_bits_[0]),
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgSOCacheSubscribed_SubscribedType, _unknown_fields_),
        -1,
        ::google::protobuf::DescriptorPool::generated_pool(),
        ::google::protobuf::MessageFactory::generated_factory(),
        sizeof(CMsgSOCacheSubscribed_SubscribedType));
    CMsgSOCacheSubscribedUpToDate_descriptor_ = file->message_type(4);
    static const int CMsgSOCacheSubscribedUpToDate_offsets_[5] = {
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgSOCacheSubscribedUpToDate, version_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgSOCacheSubscribedUpToDate, owner_soid_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgSOCacheSubscribedUpToDate, service_id_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgSOCacheSubscribedUpToDate, service_list_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgSOCacheSubscribedUpToDate, sync_version_),
    };
    CMsgSOCacheSubscribedUpToDate_reflection_ =
      new ::google::protobuf::internal::GeneratedMessageReflection(
        CMsgSOCacheSubscribedUpToDate_descriptor_,
        CMsgSOCacheSubscribedUpToDate::default_instance_,
        CMsgSOCacheSubscribedUpToDate_offsets_,
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgSOCacheSubscribedUpToDate, _has_bits_[0]),
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgSOCacheSubscribedUpToDate, _unknown_fields_),
        -1,
        ::google::protobuf::DescriptorPool::generated_pool(),
        ::google::protobuf::MessageFactory::generated_factory(),
        sizeof(CMsgSOCacheSubscribedUpToDate));
    CMsgSOCacheUnsubscribed_descriptor_ = file->message_type(5);
    static const int CMsgSOCacheUnsubscribed_offsets_[1] = {
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgSOCacheUnsubscribed, owner_),
    };
    CMsgSOCacheUnsubscribed_reflection_ =
      new ::google::protobuf::internal::GeneratedMessageReflection(
        CMsgSOCacheUnsubscribed_descriptor_,
        CMsgSOCacheUnsubscribed::default_instance_,
        CMsgSOCacheUnsubscribed_offsets_,
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgSOCacheUnsubscribed, _has_bits_[0]),
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgSOCacheUnsubscribed, _unknown_fields_),
        -1,
        ::google::protobuf::DescriptorPool::generated_pool(),
        ::google::protobuf::MessageFactory::generated_factory(),
        sizeof(CMsgSOCacheUnsubscribed));
    CMsgSOCacheSubscriptionCheck_descriptor_ = file->message_type(6);
    static const int CMsgSOCacheSubscriptionCheck_offsets_[6] = {
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgSOCacheSubscriptionCheck, owner_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgSOCacheSubscriptionCheck, version_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgSOCacheSubscriptionCheck, owner_soid_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgSOCacheSubscriptionCheck, service_id_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgSOCacheSubscriptionCheck, service_list_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgSOCacheSubscriptionCheck, sync_version_),
    };
    CMsgSOCacheSubscriptionCheck_reflection_ =
      new ::google::protobuf::internal::GeneratedMessageReflection(
        CMsgSOCacheSubscriptionCheck_descriptor_,
        CMsgSOCacheSubscriptionCheck::default_instance_,
        CMsgSOCacheSubscriptionCheck_offsets_,
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgSOCacheSubscriptionCheck, _has_bits_[0]),
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgSOCacheSubscriptionCheck, _unknown_fields_),
        -1,
        ::google::protobuf::DescriptorPool::generated_pool(),
        ::google::protobuf::MessageFactory::generated_factory(),
        sizeof(CMsgSOCacheSubscriptionCheck));
    CMsgSOCacheSubscriptionRefresh_descriptor_ = file->message_type(7);
    static const int CMsgSOCacheSubscriptionRefresh_offsets_[2] = {
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgSOCacheSubscriptionRefresh, owner_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgSOCacheSubscriptionRefresh, owner_soid_),
    };
    CMsgSOCacheSubscriptionRefresh_reflection_ =
      new ::google::protobuf::internal::GeneratedMessageReflection(
        CMsgSOCacheSubscriptionRefresh_descriptor_,
        CMsgSOCacheSubscriptionRefresh::default_instance_,
        CMsgSOCacheSubscriptionRefresh_offsets_,
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgSOCacheSubscriptionRefresh, _has_bits_[0]),
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgSOCacheSubscriptionRefresh, _unknown_fields_),
        -1,
        ::google::protobuf::DescriptorPool::generated_pool(),
        ::google::protobuf::MessageFactory::generated_factory(),
        sizeof(CMsgSOCacheSubscriptionRefresh));
    CMsgSOCacheVersion_descriptor_ = file->message_type(8);
    static const int CMsgSOCacheVersion_offsets_[1] = {
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgSOCacheVersion, version_),
    };
    CMsgSOCacheVersion_reflection_ =
      new ::google::protobuf::internal::GeneratedMessageReflection(
        CMsgSOCacheVersion_descriptor_,
        CMsgSOCacheVersion::default_instance_,
        CMsgSOCacheVersion_offsets_,
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgSOCacheVersion, _has_bits_[0]),
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgSOCacheVersion, _unknown_fields_),
        -1,
        ::google::protobuf::DescriptorPool::generated_pool(),
        ::google::protobuf::MessageFactory::generated_factory(),
        sizeof(CMsgSOCacheVersion));
    CMsgGCMultiplexMessage_descriptor_ = file->message_type(9);
    static const int CMsgGCMultiplexMessage_offsets_[3] = {
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgGCMultiplexMessage, msgtype_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgGCMultiplexMessage, payload_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgGCMultiplexMessage, steamids_),
    };
    CMsgGCMultiplexMessage_reflection_ =
      new ::google::protobuf::internal::GeneratedMessageReflection(
        CMsgGCMultiplexMessage_descriptor_,
        CMsgGCMultiplexMessage::default_instance_,
        CMsgGCMultiplexMessage_offsets_,
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgGCMultiplexMessage, _has_bits_[0]),
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgGCMultiplexMessage, _unknown_fields_),
        -1,
        ::google::protobuf::DescriptorPool::generated_pool(),
        ::google::protobuf::MessageFactory::generated_factory(),
        sizeof(CMsgGCMultiplexMessage));
    CGCToGCMsgMasterAck_descriptor_ = file->message_type(10);
    static const int CGCToGCMsgMasterAck_offsets_[4] = {
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CGCToGCMsgMasterAck, dir_index_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CGCToGCMsgMasterAck, machine_name_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CGCToGCMsgMasterAck, process_name_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CGCToGCMsgMasterAck, type_instances_),
    };
    CGCToGCMsgMasterAck_reflection_ =
      new ::google::protobuf::internal::GeneratedMessageReflection(
        CGCToGCMsgMasterAck_descriptor_,
        CGCToGCMsgMasterAck::default_instance_,
        CGCToGCMsgMasterAck_offsets_,
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CGCToGCMsgMasterAck, _has_bits_[0]),
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CGCToGCMsgMasterAck, _unknown_fields_),
        -1,
        ::google::protobuf::DescriptorPool::generated_pool(),
        ::google::protobuf::MessageFactory::generated_factory(),
        sizeof(CGCToGCMsgMasterAck));
    CGCToGCMsgMasterAck_Response_descriptor_ = file->message_type(11);
    static const int CGCToGCMsgMasterAck_Response_offsets_[1] = {
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CGCToGCMsgMasterAck_Response, eresult_),
    };
    CGCToGCMsgMasterAck_Response_reflection_ =
      new ::google::protobuf::internal::GeneratedMessageReflection(
        CGCToGCMsgMasterAck_Response_descriptor_,
        CGCToGCMsgMasterAck_Response::default_instance_,
        CGCToGCMsgMasterAck_Response_offsets_,
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CGCToGCMsgMasterAck_Response, _has_bits_[0]),
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CGCToGCMsgMasterAck_Response, _unknown_fields_),
        -1,
        ::google::protobuf::DescriptorPool::generated_pool(),
        ::google::protobuf::MessageFactory::generated_factory(),
        sizeof(CGCToGCMsgMasterAck_Response));
    CGCToGCMsgMasterStartupComplete_descriptor_ = file->message_type(12);
    static const int CGCToGCMsgMasterStartupComplete_offsets_[1] = {
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CGCToGCMsgMasterStartupComplete, gc_info_),
    };
    CGCToGCMsgMasterStartupComplete_reflection_ =
      new ::google::protobuf::internal::GeneratedMessageReflection(
        CGCToGCMsgMasterStartupComplete_descriptor_,
        CGCToGCMsgMasterStartupComplete::default_instance_,
        CGCToGCMsgMasterStartupComplete_offsets_,
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CGCToGCMsgMasterStartupComplete, _has_bits_[0]),
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CGCToGCMsgMasterStartupComplete, _unknown_fields_),
        -1,
        ::google::protobuf::DescriptorPool::generated_pool(),
        ::google::protobuf::MessageFactory::generated_factory(),
        sizeof(CGCToGCMsgMasterStartupComplete));
    CGCToGCMsgMasterStartupComplete_GCInfo_descriptor_ = CGCToGCMsgMasterStartupComplete_descriptor_->nested_type(0);
    static const int CGCToGCMsgMasterStartupComplete_GCInfo_offsets_[2] = {
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CGCToGCMsgMasterStartupComplete_GCInfo, dir_index_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CGCToGCMsgMasterStartupComplete_GCInfo, machine_name_),
    };
    CGCToGCMsgMasterStartupComplete_GCInfo_reflection_ =
      new ::google::protobuf::internal::GeneratedMessageReflection(
        CGCToGCMsgMasterStartupComplete_GCInfo_descriptor_,
        CGCToGCMsgMasterStartupComplete_GCInfo::default_instance_,
        CGCToGCMsgMasterStartupComplete_GCInfo_offsets_,
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CGCToGCMsgMasterStartupComplete_GCInfo, _has_bits_[0]),
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CGCToGCMsgMasterStartupComplete_GCInfo, _unknown_fields_),
        -1,
        ::google::protobuf::DescriptorPool::generated_pool(),
        ::google::protobuf::MessageFactory::generated_factory(),
        sizeof(CGCToGCMsgMasterStartupComplete_GCInfo));
    CGCToGCMsgRouted_descriptor_ = file->message_type(13);
    static const int CGCToGCMsgRouted_offsets_[3] = {
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CGCToGCMsgRouted, msg_type_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CGCToGCMsgRouted, sender_id_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CGCToGCMsgRouted, net_message_),
    };
    CGCToGCMsgRouted_reflection_ =
      new ::google::protobuf::internal::GeneratedMessageReflection(
        CGCToGCMsgRouted_descriptor_,
        CGCToGCMsgRouted::default_instance_,
        CGCToGCMsgRouted_offsets_,
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CGCToGCMsgRouted, _has_bits_[0]),
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CGCToGCMsgRouted, _unknown_fields_),
        -1,
        ::google::protobuf::DescriptorPool::generated_pool(),
        ::google::protobuf::MessageFactory::generated_factory(),
        sizeof(CGCToGCMsgRouted));
    CGCToGCMsgRoutedReply_descriptor_ = file->message_type(14);
    static const int CGCToGCMsgRoutedReply_offsets_[2] = {
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CGCToGCMsgRoutedReply, msg_type_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CGCToGCMsgRoutedReply, net_message_),
    };
    CGCToGCMsgRoutedReply_reflection_ =
      new ::google::protobuf::internal::GeneratedMessageReflection(
        CGCToGCMsgRoutedReply_descriptor_,
        CGCToGCMsgRoutedReply::default_instance_,
        CGCToGCMsgRoutedReply_offsets_,
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CGCToGCMsgRoutedReply, _has_bits_[0]),
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CGCToGCMsgRoutedReply, _unknown_fields_),
        -1,
        ::google::protobuf::DescriptorPool::generated_pool(),
        ::google::protobuf::MessageFactory::generated_factory(),
        sizeof(CGCToGCMsgRoutedReply));
    CMsgGCUpdateSubGCSessionInfo_descriptor_ = file->message_type(15);
    static const int CMsgGCUpdateSubGCSessionInfo_offsets_[1] = {
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgGCUpdateSubGCSessionInfo, updates_),
    };
    CMsgGCUpdateSubGCSessionInfo_reflection_ =
      new ::google::protobuf::internal::GeneratedMessageReflection(
        CMsgGCUpdateSubGCSessionInfo_descriptor_,
        CMsgGCUpdateSubGCSessionInfo::default_instance_,
        CMsgGCUpdateSubGCSessionInfo_offsets_,
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgGCUpdateSubGCSessionInfo, _has_bits_[0]),
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgGCUpdateSubGCSessionInfo, _unknown_fields_),
        -1,
        ::google::protobuf::DescriptorPool::generated_pool(),
        ::google::protobuf::MessageFactory::generated_factory(),
        sizeof(CMsgGCUpdateSubGCSessionInfo));
    CMsgGCUpdateSubGCSessionInfo_CMsgUpdate_descriptor_ = CMsgGCUpdateSubGCSessionInfo_descriptor_->nested_type(0);
    static const int CMsgGCUpdateSubGCSessionInfo_CMsgUpdate_offsets_[3] = {
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgGCUpdateSubGCSessionInfo_CMsgUpdate, steamid_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgGCUpdateSubGCSessionInfo_CMsgUpdate, ip_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgGCUpdateSubGCSessionInfo_CMsgUpdate, trusted_),
    };
    CMsgGCUpdateSubGCSessionInfo_CMsgUpdate_reflection_ =
      new ::google::protobuf::internal::GeneratedMessageReflection(
        CMsgGCUpdateSubGCSessionInfo_CMsgUpdate_descriptor_,
        CMsgGCUpdateSubGCSessionInfo_CMsgUpdate::default_instance_,
        CMsgGCUpdateSubGCSessionInfo_CMsgUpdate_offsets_,
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgGCUpdateSubGCSessionInfo_CMsgUpdate, _has_bits_[0]),
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgGCUpdateSubGCSessionInfo_CMsgUpdate, _unknown_fields_),
        -1,
        ::google::protobuf::DescriptorPool::generated_pool(),
        ::google::protobuf::MessageFactory::generated_factory(),
        sizeof(CMsgGCUpdateSubGCSessionInfo_CMsgUpdate));
    CMsgGCRequestSubGCSessionInfo_descriptor_ = file->message_type(16);
    static const int CMsgGCRequestSubGCSessionInfo_offsets_[1] = {
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgGCRequestSubGCSessionInfo, steamid_),
    };
    CMsgGCRequestSubGCSessionInfo_reflection_ =
      new ::google::protobuf::internal::GeneratedMessageReflection(
        CMsgGCRequestSubGCSessionInfo_descriptor_,
        CMsgGCRequestSubGCSessionInfo::default_instance_,
        CMsgGCRequestSubGCSessionInfo_offsets_,
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgGCRequestSubGCSessionInfo, _has_bits_[0]),
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgGCRequestSubGCSessionInfo, _unknown_fields_),
        -1,
        ::google::protobuf::DescriptorPool::generated_pool(),
        ::google::protobuf::MessageFactory::generated_factory(),
        sizeof(CMsgGCRequestSubGCSessionInfo));
    CMsgGCRequestSubGCSessionInfoResponse_descriptor_ = file->message_type(17);
    static const int CMsgGCRequestSubGCSessionInfoResponse_offsets_[2] = {
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgGCRequestSubGCSessionInfoResponse, ip_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgGCRequestSubGCSessionInfoResponse, trusted_),
    };
    CMsgGCRequestSubGCSessionInfoResponse_reflection_ =
      new ::google::protobuf::internal::GeneratedMessageReflection(
        CMsgGCRequestSubGCSessionInfoResponse_descriptor_,
        CMsgGCRequestSubGCSessionInfoResponse::default_instance_,
        CMsgGCRequestSubGCSessionInfoResponse_offsets_,
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgGCRequestSubGCSessionInfoResponse, _has_bits_[0]),
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgGCRequestSubGCSessionInfoResponse, _unknown_fields_),
        -1,
        ::google::protobuf::DescriptorPool::generated_pool(),
        ::google::protobuf::MessageFactory::generated_factory(),
        sizeof(CMsgGCRequestSubGCSessionInfoResponse));
    CMsgGCToGCIncrementRecruitmentLevel_descriptor_ = file->message_type(18);
    static const int CMsgGCToGCIncrementRecruitmentLevel_offsets_[1] = {
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgGCToGCIncrementRecruitmentLevel, steamid_),
    };
    CMsgGCToGCIncrementRecruitmentLevel_reflection_ =
      new ::google::protobuf::internal::GeneratedMessageReflection(
        CMsgGCToGCIncrementRecruitmentLevel_descriptor_,
        CMsgGCToGCIncrementRecruitmentLevel::default_instance_,
        CMsgGCToGCIncrementRecruitmentLevel_offsets_,
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgGCToGCIncrementRecruitmentLevel, _has_bits_[0]),
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgGCToGCIncrementRecruitmentLevel, _unknown_fields_),
        -1,
        ::google::protobuf::DescriptorPool::generated_pool(),
        ::google::protobuf::MessageFactory::generated_factory(),
        sizeof(CMsgGCToGCIncrementRecruitmentLevel));
    CMsgSOCacheHaveVersion_descriptor_ = file->message_type(19);
    static const int CMsgSOCacheHaveVersion_offsets_[3] = {
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgSOCacheHaveVersion, soid_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgSOCacheHaveVersion, version_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgSOCacheHaveVersion, service_id_),
    };
    CMsgSOCacheHaveVersion_reflection_ =
      new ::google::protobuf::internal::GeneratedMessageReflection(
        CMsgSOCacheHaveVersion_descriptor_,
        CMsgSOCacheHaveVersion::default_instance_,
        CMsgSOCacheHaveVersion_offsets_,
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgSOCacheHaveVersion, _has_bits_[0]),
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgSOCacheHaveVersion, _unknown_fields_),
        -1,
        ::google::protobuf::DescriptorPool::generated_pool(),
        ::google::protobuf::MessageFactory::generated_factory(),
        sizeof(CMsgSOCacheHaveVersion));
    CMsgConnectionStatus_descriptor_ = file->message_type(20);
    static const int CMsgConnectionStatus_offsets_[6] = {
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgConnectionStatus, status_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgConnectionStatus, client_session_need_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgConnectionStatus, queue_position_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgConnectionStatus, queue_size_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgConnectionStatus, wait_seconds_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgConnectionStatus, estimated_wait_seconds_remaining_),
    };
    CMsgConnectionStatus_reflection_ =
      new ::google::protobuf::internal::GeneratedMessageReflection(
        CMsgConnectionStatus_descriptor_,
        CMsgConnectionStatus::default_instance_,
        CMsgConnectionStatus_offsets_,
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgConnectionStatus, _has_bits_[0]),
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgConnectionStatus, _unknown_fields_),
        -1,
        ::google::protobuf::DescriptorPool::generated_pool(),
        ::google::protobuf::MessageFactory::generated_factory(),
        sizeof(CMsgConnectionStatus));
    CMsgGCToGCSOCacheSubscribe_descriptor_ = file->message_type(21);
    static const int CMsgGCToGCSOCacheSubscribe_offsets_[4] = {
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgGCToGCSOCacheSubscribe, subscriber_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgGCToGCSOCacheSubscribe, subscribe_to_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgGCToGCSOCacheSubscribe, sync_version_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgGCToGCSOCacheSubscribe, have_versions_),
    };
    CMsgGCToGCSOCacheSubscribe_reflection_ =
      new ::google::protobuf::internal::GeneratedMessageReflection(
        CMsgGCToGCSOCacheSubscribe_descriptor_,
        CMsgGCToGCSOCacheSubscribe::default_instance_,
        CMsgGCToGCSOCacheSubscribe_offsets_,
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgGCToGCSOCacheSubscribe, _has_bits_[0]),
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgGCToGCSOCacheSubscribe, _unknown_fields_),
        -1,
        ::google::protobuf::DescriptorPool::generated_pool(),
        ::google::protobuf::MessageFactory::generated_factory(),
        sizeof(CMsgGCToGCSOCacheSubscribe));
    CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions_descriptor_ = CMsgGCToGCSOCacheSubscribe_descriptor_->nested_type(0);
    static const int CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions_offsets_[2] = {
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions, service_id_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions, version_),
    };
    CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions_reflection_ =
      new ::google::protobuf::internal::GeneratedMessageReflection(
        CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions_descriptor_,
        CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions::default_instance_,
        CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions_offsets_,
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions, _has_bits_[0]),
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions, _unknown_fields_),
        -1,
        ::google::protobuf::DescriptorPool::generated_pool(),
        ::google::protobuf::MessageFactory::generated_factory(),
        sizeof(CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions));
    CMsgGCToGCSOCacheUnsubscribe_descriptor_ = file->message_type(22);
    static const int CMsgGCToGCSOCacheUnsubscribe_offsets_[2] = {
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgGCToGCSOCacheUnsubscribe, subscriber_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgGCToGCSOCacheUnsubscribe, unsubscribe_from_),
    };
    CMsgGCToGCSOCacheUnsubscribe_reflection_ =
      new ::google::protobuf::internal::GeneratedMessageReflection(
        CMsgGCToGCSOCacheUnsubscribe_descriptor_,
        CMsgGCToGCSOCacheUnsubscribe::default_instance_,
        CMsgGCToGCSOCacheUnsubscribe_offsets_,
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgGCToGCSOCacheUnsubscribe, _has_bits_[0]),
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgGCToGCSOCacheUnsubscribe, _unknown_fields_),
        -1,
        ::google::protobuf::DescriptorPool::generated_pool(),
        ::google::protobuf::MessageFactory::generated_factory(),
        sizeof(CMsgGCToGCSOCacheUnsubscribe));
    CMsgGCClientPing_descriptor_ = file->message_type(23);
    static const int CMsgGCClientPing_offsets_[1] = {
    };
    CMsgGCClientPing_reflection_ =
      new ::google::protobuf::internal::GeneratedMessageReflection(
        CMsgGCClientPing_descriptor_,
        CMsgGCClientPing::default_instance_,
        CMsgGCClientPing_offsets_,
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgGCClientPing, _has_bits_[0]),
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgGCClientPing, _unknown_fields_),
        -1,
        ::google::protobuf::DescriptorPool::generated_pool(),
        ::google::protobuf::MessageFactory::generated_factory(),
        sizeof(CMsgGCClientPing));
    PartnerAccountType_descriptor_ = file->enum_type(0);
    GCConnectionStatus_descriptor_ = file->enum_type(1);
  }
  
  namespace {
  
  GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
  inline void protobuf_AssignDescriptorsOnce() {
    ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
                   &protobuf_AssignDesc_gcsdk_5fgcmessages_2eproto);
  }
  
  void protobuf_RegisterTypes(const ::std::string&) {
    protobuf_AssignDescriptorsOnce();
    ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      CMsgSOIDOwner_descriptor_, &CMsgSOIDOwner::default_instance());
    ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      CMsgSOSingleObject_descriptor_, &CMsgSOSingleObject::default_instance());
    ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      CMsgSOMultipleObjects_descriptor_, &CMsgSOMultipleObjects::default_instance());
    ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      CMsgSOMultipleObjects_SingleObject_descriptor_, &CMsgSOMultipleObjects_SingleObject::default_instance());
    ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      CMsgSOCacheSubscribed_descriptor_, &CMsgSOCacheSubscribed::default_instance());
    ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      CMsgSOCacheSubscribed_SubscribedType_descriptor_, &CMsgSOCacheSubscribed_SubscribedType::default_instance());
    ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      CMsgSOCacheSubscribedUpToDate_descriptor_, &CMsgSOCacheSubscribedUpToDate::default_instance());
    ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      CMsgSOCacheUnsubscribed_descriptor_, &CMsgSOCacheUnsubscribed::default_instance());
    ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      CMsgSOCacheSubscriptionCheck_descriptor_, &CMsgSOCacheSubscriptionCheck::default_instance());
    ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      CMsgSOCacheSubscriptionRefresh_descriptor_, &CMsgSOCacheSubscriptionRefresh::default_instance());
    ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      CMsgSOCacheVersion_descriptor_, &CMsgSOCacheVersion::default_instance());
    ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      CMsgGCMultiplexMessage_descriptor_, &CMsgGCMultiplexMessage::default_instance());
    ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      CGCToGCMsgMasterAck_descriptor_, &CGCToGCMsgMasterAck::default_instance());
    ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      CGCToGCMsgMasterAck_Response_descriptor_, &CGCToGCMsgMasterAck_Response::default_instance());
    ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      CGCToGCMsgMasterStartupComplete_descriptor_, &CGCToGCMsgMasterStartupComplete::default_instance());
    ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      CGCToGCMsgMasterStartupComplete_GCInfo_descriptor_, &CGCToGCMsgMasterStartupComplete_GCInfo::default_instance());
    ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      CGCToGCMsgRouted_descriptor_, &CGCToGCMsgRouted::default_instance());
    ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      CGCToGCMsgRoutedReply_descriptor_, &CGCToGCMsgRoutedReply::default_instance());
    ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      CMsgGCUpdateSubGCSessionInfo_descriptor_, &CMsgGCUpdateSubGCSessionInfo::default_instance());
    ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      CMsgGCUpdateSubGCSessionInfo_CMsgUpdate_descriptor_, &CMsgGCUpdateSubGCSessionInfo_CMsgUpdate::default_instance());
    ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      CMsgGCRequestSubGCSessionInfo_descriptor_, &CMsgGCRequestSubGCSessionInfo::default_instance());
    ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      CMsgGCRequestSubGCSessionInfoResponse_descriptor_, &CMsgGCRequestSubGCSessionInfoResponse::default_instance());
    ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      CMsgGCToGCIncrementRecruitmentLevel_descriptor_, &CMsgGCToGCIncrementRecruitmentLevel::default_instance());
    ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      CMsgSOCacheHaveVersion_descriptor_, &CMsgSOCacheHaveVersion::default_instance());
    ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      CMsgConnectionStatus_descriptor_, &CMsgConnectionStatus::default_instance());
    ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      CMsgGCToGCSOCacheSubscribe_descriptor_, &CMsgGCToGCSOCacheSubscribe::default_instance());
    ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions_descriptor_, &CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions::default_instance());
    ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      CMsgGCToGCSOCacheUnsubscribe_descriptor_, &CMsgGCToGCSOCacheUnsubscribe::default_instance());
    ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      CMsgGCClientPing_descriptor_, &CMsgGCClientPing::default_instance());
  }
  
  }  // namespace
  
  void protobuf_ShutdownFile_gcsdk_5fgcmessages_2eproto() {
    delete CMsgSOIDOwner::default_instance_;
    delete CMsgSOIDOwner_reflection_;
    delete CMsgSOSingleObject::default_instance_;
    delete CMsgSOSingleObject_reflection_;
    delete CMsgSOMultipleObjects::default_instance_;
    delete CMsgSOMultipleObjects_reflection_;
    delete CMsgSOMultipleObjects_SingleObject::default_instance_;
    delete CMsgSOMultipleObjects_SingleObject_reflection_;
    delete CMsgSOCacheSubscribed::default_instance_;
    delete CMsgSOCacheSubscribed_reflection_;
    delete CMsgSOCacheSubscribed_SubscribedType::default_instance_;
    delete CMsgSOCacheSubscribed_SubscribedType_reflection_;
    delete CMsgSOCacheSubscribedUpToDate::default_instance_;
    delete CMsgSOCacheSubscribedUpToDate_reflection_;
    delete CMsgSOCacheUnsubscribed::default_instance_;
    delete CMsgSOCacheUnsubscribed_reflection_;
    delete CMsgSOCacheSubscriptionCheck::default_instance_;
    delete CMsgSOCacheSubscriptionCheck_reflection_;
    delete CMsgSOCacheSubscriptionRefresh::default_instance_;
    delete CMsgSOCacheSubscriptionRefresh_reflection_;
    delete CMsgSOCacheVersion::default_instance_;
    delete CMsgSOCacheVersion_reflection_;
    delete CMsgGCMultiplexMessage::default_instance_;
    delete CMsgGCMultiplexMessage_reflection_;
    delete CGCToGCMsgMasterAck::default_instance_;
    delete CGCToGCMsgMasterAck_reflection_;
    delete CGCToGCMsgMasterAck_Response::default_instance_;
    delete CGCToGCMsgMasterAck_Response_reflection_;
    delete CGCToGCMsgMasterStartupComplete::default_instance_;
    delete CGCToGCMsgMasterStartupComplete_reflection_;
    delete CGCToGCMsgMasterStartupComplete_GCInfo::default_instance_;
    delete CGCToGCMsgMasterStartupComplete_GCInfo_reflection_;
    delete CGCToGCMsgRouted::default_instance_;
    delete CGCToGCMsgRouted_reflection_;
    delete CGCToGCMsgRoutedReply::default_instance_;
    delete CGCToGCMsgRoutedReply_reflection_;
    delete CMsgGCUpdateSubGCSessionInfo::default_instance_;
    delete CMsgGCUpdateSubGCSessionInfo_reflection_;
    delete CMsgGCUpdateSubGCSessionInfo_CMsgUpdate::default_instance_;
    delete CMsgGCUpdateSubGCSessionInfo_CMsgUpdate_reflection_;
    delete CMsgGCRequestSubGCSessionInfo::default_instance_;
    delete CMsgGCRequestSubGCSessionInfo_reflection_;
    delete CMsgGCRequestSubGCSessionInfoResponse::default_instance_;
    delete CMsgGCRequestSubGCSessionInfoResponse_reflection_;
    delete CMsgGCToGCIncrementRecruitmentLevel::default_instance_;
    delete CMsgGCToGCIncrementRecruitmentLevel_reflection_;
    delete CMsgSOCacheHaveVersion::default_instance_;
    delete CMsgSOCacheHaveVersion_reflection_;
    delete CMsgConnectionStatus::default_instance_;
    delete CMsgConnectionStatus_reflection_;
    delete CMsgGCToGCSOCacheSubscribe::default_instance_;
    delete CMsgGCToGCSOCacheSubscribe_reflection_;
    delete CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions::default_instance_;
    delete CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions_reflection_;
    delete CMsgGCToGCSOCacheUnsubscribe::default_instance_;
    delete CMsgGCToGCSOCacheUnsubscribe_reflection_;
    delete CMsgGCClientPing::default_instance_;
    delete CMsgGCClientPing_reflection_;
  }
  
  void protobuf_AddDesc_gcsdk_5fgcmessages_2eproto() {
    static bool already_here = false;
    if (already_here) return;
    already_here = true;
    GOOGLE_PROTOBUF_VERIFY_VERSION;
  
    ::protobuf_AddDesc_steammessages_2eproto();
    ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
      "\n\026gcsdk_gcmessages.proto\032\023steammessages."
      "proto\")\n\rCMsgSOIDOwner\022\014\n\004type\030\001 \001(\r\022\n\n\002"
      "id\030\002 \001(\004\"\222\001\n\022CMsgSOSingleObject\022\r\n\005owner"
      "\030\001 \001(\006\022\017\n\007type_id\030\002 \001(\005\022\023\n\013object_data\030\003"
      " \001(\014\022\017\n\007version\030\004 \001(\006\022\"\n\nowner_soid\030\005 \001("
      "\0132\016.CMsgSOIDOwner\022\022\n\nservice_id\030\006 \001(\r\"\333\001"
      "\n\025CMsgSOMultipleObjects\022\r\n\005owner\030\001 \001(\006\0224"
      "\n\007objects\030\002 \003(\0132#.CMsgSOMultipleObjects."
      "SingleObject\022\017\n\007version\030\003 \001(\006\022\"\n\nowner_s"
      "oid\030\006 \001(\0132\016.CMsgSOIDOwner\022\022\n\nservice_id\030"
      "\007 \001(\r\0324\n\014SingleObject\022\017\n\007type_id\030\001 \001(\005\022\023"
      "\n\013object_data\030\002 \001(\014\"\213\002\n\025CMsgSOCacheSubsc"
      "ribed\022\r\n\005owner\030\001 \001(\006\0226\n\007objects\030\002 \003(\0132%."
      "CMsgSOCacheSubscribed.SubscribedType\022\017\n\007"
      "version\030\003 \001(\006\022\"\n\nowner_soid\030\004 \001(\0132\016.CMsg"
      "SOIDOwner\022\022\n\nservice_id\030\005 \001(\r\022\024\n\014service"
      "_list\030\006 \003(\r\022\024\n\014sync_version\030\007 \001(\006\0326\n\016Sub"
      "scribedType\022\017\n\007type_id\030\001 \001(\005\022\023\n\013object_d"
      "ata\030\002 \003(\014\"\224\001\n\035CMsgSOCacheSubscribedUpToD"
      "ate\022\017\n\007version\030\001 \001(\006\022\"\n\nowner_soid\030\002 \001(\013"
      "2\016.CMsgSOIDOwner\022\022\n\nservice_id\030\003 \001(\r\022\024\n\014"
      "service_list\030\004 \003(\r\022\024\n\014sync_version\030\005 \001(\006"
      "\"(\n\027CMsgSOCacheUnsubscribed\022\r\n\005owner\030\001 \001"
      "(\006\"\242\001\n\034CMsgSOCacheSubscriptionCheck\022\r\n\005o"
      "wner\030\001 \001(\006\022\017\n\007version\030\002 \001(\006\022\"\n\nowner_soi"
      "d\030\003 \001(\0132\016.CMsgSOIDOwner\022\022\n\nservice_id\030\004 "
      "\001(\r\022\024\n\014service_list\030\005 \003(\r\022\024\n\014sync_versio"
      "n\030\006 \001(\006\"S\n\036CMsgSOCacheSubscriptionRefres"
      "h\022\r\n\005owner\030\001 \001(\006\022\"\n\nowner_soid\030\002 \001(\0132\016.C"
      "MsgSOIDOwner\"%\n\022CMsgSOCacheVersion\022\017\n\007ve"
      "rsion\030\001 \001(\006\"L\n\026CMsgGCMultiplexMessage\022\017\n"
      "\007msgtype\030\001 \001(\r\022\017\n\007payload\030\002 \001(\014\022\020\n\010steam"
      "ids\030\003 \003(\006\"l\n\023CGCToGCMsgMasterAck\022\021\n\tdir_"
      "index\030\001 \001(\r\022\024\n\014machine_name\030\003 \001(\t\022\024\n\014pro"
      "cess_name\030\004 \001(\t\022\026\n\016type_instances\030\005 \003(\r\""
      "2\n\034CGCToGCMsgMasterAck_Response\022\022\n\007eresu"
      "lt\030\001 \001(\005:\0012\"\216\001\n\037CGCToGCMsgMasterStartupC"
      "omplete\0228\n\007gc_info\030\001 \003(\0132\'.CGCToGCMsgMas"
      "terStartupComplete.GCInfo\0321\n\006GCInfo\022\021\n\td"
      "ir_index\030\001 \001(\r\022\024\n\014machine_name\030\002 \001(\t\"L\n\020"
      "CGCToGCMsgRouted\022\020\n\010msg_type\030\001 \001(\r\022\021\n\tse"
      "nder_id\030\002 \001(\006\022\023\n\013net_message\030\003 \001(\014\">\n\025CG"
      "CToGCMsgRoutedReply\022\020\n\010msg_type\030\001 \001(\r\022\023\n"
      "\013net_message\030\002 \001(\014\"\225\001\n\034CMsgGCUpdateSubGC"
      "SessionInfo\0229\n\007updates\030\001 \003(\0132(.CMsgGCUpd"
      "ateSubGCSessionInfo.CMsgUpdate\032:\n\nCMsgUp"
      "date\022\017\n\007steamid\030\001 \001(\006\022\n\n\002ip\030\002 \001(\007\022\017\n\007tru"
      "sted\030\003 \001(\010\"0\n\035CMsgGCRequestSubGCSessionI"
      "nfo\022\017\n\007steamid\030\001 \001(\006\"D\n%CMsgGCRequestSub"
      "GCSessionInfoResponse\022\n\n\002ip\030\001 \001(\007\022\017\n\007tru"
      "sted\030\002 \001(\010\"6\n#CMsgGCToGCIncrementRecruit"
      "mentLevel\022\017\n\007steamid\030\001 \001(\006\"[\n\026CMsgSOCach"
      "eHaveVersion\022\034\n\004soid\030\001 \001(\0132\016.CMsgSOIDOwn"
      "er\022\017\n\007version\030\002 \001(\006\022\022\n\nservice_id\030\003 \001(\r\""
      "\345\001\n\024CMsgConnectionStatus\022D\n\006status\030\001 \001(\016"
      "2\023.GCConnectionStatus:\037GCConnectionStatu"
      "s_HAVE_SESSION\022\033\n\023client_session_need\030\002 "
      "\001(\r\022\026\n\016queue_position\030\003 \001(\005\022\022\n\nqueue_siz"
      "e\030\004 \001(\005\022\024\n\014wait_seconds\030\005 \001(\005\022(\n estimat"
      "ed_wait_seconds_remaining\030\006 \001(\005\"\332\001\n\032CMsg"
      "GCToGCSOCacheSubscribe\022\022\n\nsubscriber\030\001 \001"
      "(\006\022\024\n\014subscribe_to\030\002 \001(\006\022\024\n\014sync_version"
      "\030\003 \001(\006\022C\n\rhave_versions\030\004 \003(\0132,.CMsgGCTo"
      "GCSOCacheSubscribe.CMsgHaveVersions\0327\n\020C"
      "MsgHaveVersions\022\022\n\nservice_id\030\001 \001(\r\022\017\n\007v"
      "ersion\030\002 \001(\004\"L\n\034CMsgGCToGCSOCacheUnsubsc"
      "ribe\022\022\n\nsubscriber\030\001 \001(\006\022\030\n\020unsubscribe_"
      "from\030\002 \001(\006\"\022\n\020CMsgGCClientPing*T\n\022Partne"
      "rAccountType\022\020\n\014PARTNER_NONE\020\000\022\031\n\025PARTNE"
      "R_PERFECT_WORLD\020\001\022\021\n\rPARTNER_NEXON\020\002*\367\001\n"
      "\022GCConnectionStatus\022#\n\037GCConnectionStatu"
      "s_HAVE_SESSION\020\000\022$\n GCConnectionStatus_G"
      "C_GOING_DOWN\020\001\022!\n\035GCConnectionStatus_NO_"
      "SESSION\020\002\0220\n,GCConnectionStatus_NO_SESSI"
      "ON_IN_LOGON_QUEUE\020\003\022\037\n\033GCConnectionStatu"
      "s_NO_STEAM\020\004\022 \n\034GCConnectionStatus_SUSPE"
      "NDED\020\005B\005H\001\200\001\000", 3053);
    ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
      "gcsdk_gcmessages.proto", &protobuf_RegisterTypes);
    CMsgSOIDOwner::default_instance_ = new CMsgSOIDOwner();
    CMsgSOSingleObject::default_instance_ = new CMsgSOSingleObject();
    CMsgSOMultipleObjects::default_instance_ = new CMsgSOMultipleObjects();
    CMsgSOMultipleObjects_SingleObject::default_instance_ = new CMsgSOMultipleObjects_SingleObject();
    CMsgSOCacheSubscribed::default_instance_ = new CMsgSOCacheSubscribed();
    CMsgSOCacheSubscribed_SubscribedType::default_instance_ = new CMsgSOCacheSubscribed_SubscribedType();
    CMsgSOCacheSubscribedUpToDate::default_instance_ = new CMsgSOCacheSubscribedUpToDate();
    CMsgSOCacheUnsubscribed::default_instance_ = new CMsgSOCacheUnsubscribed();
    CMsgSOCacheSubscriptionCheck::default_instance_ = new CMsgSOCacheSubscriptionCheck();
    CMsgSOCacheSubscriptionRefresh::default_instance_ = new CMsgSOCacheSubscriptionRefresh();
    CMsgSOCacheVersion::default_instance_ = new CMsgSOCacheVersion();
    CMsgGCMultiplexMessage::default_instance_ = new CMsgGCMultiplexMessage();
    CGCToGCMsgMasterAck::default_instance_ = new CGCToGCMsgMasterAck();
    CGCToGCMsgMasterAck_Response::default_instance_ = new CGCToGCMsgMasterAck_Response();
    CGCToGCMsgMasterStartupComplete::default_instance_ = new CGCToGCMsgMasterStartupComplete();
    CGCToGCMsgMasterStartupComplete_GCInfo::default_instance_ = new CGCToGCMsgMasterStartupComplete_GCInfo();
    CGCToGCMsgRouted::default_instance_ = new CGCToGCMsgRouted();
    CGCToGCMsgRoutedReply::default_instance_ = new CGCToGCMsgRoutedReply();
    CMsgGCUpdateSubGCSessionInfo::default_instance_ = new CMsgGCUpdateSubGCSessionInfo();
    CMsgGCUpdateSubGCSessionInfo_CMsgUpdate::default_instance_ = new CMsgGCUpdateSubGCSessionInfo_CMsgUpdate();
    CMsgGCRequestSubGCSessionInfo::default_instance_ = new CMsgGCRequestSubGCSessionInfo();
    CMsgGCRequestSubGCSessionInfoResponse::default_instance_ = new CMsgGCRequestSubGCSessionInfoResponse();
    CMsgGCToGCIncrementRecruitmentLevel::default_instance_ = new CMsgGCToGCIncrementRecruitmentLevel();
    CMsgSOCacheHaveVersion::default_instance_ = new CMsgSOCacheHaveVersion();
    CMsgConnectionStatus::default_instance_ = new CMsgConnectionStatus();
    CMsgGCToGCSOCacheSubscribe::default_instance_ = new CMsgGCToGCSOCacheSubscribe();
    CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions::default_instance_ = new CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions();
    CMsgGCToGCSOCacheUnsubscribe::default_instance_ = new CMsgGCToGCSOCacheUnsubscribe();
    CMsgGCClientPing::default_instance_ = new CMsgGCClientPing();
    CMsgSOIDOwner::default_instance_->InitAsDefaultInstance();
    CMsgSOSingleObject::default_instance_->InitAsDefaultInstance();
    CMsgSOMultipleObjects::default_instance_->InitAsDefaultInstance();
    CMsgSOMultipleObjects_SingleObject::default_instance_->InitAsDefaultInstance();
    CMsgSOCacheSubscribed::default_instance_->InitAsDefaultInstance();
    CMsgSOCacheSubscribed_SubscribedType::default_instance_->InitAsDefaultInstance();
    CMsgSOCacheSubscribedUpToDate::default_instance_->InitAsDefaultInstance();
    CMsgSOCacheUnsubscribed::default_instance_->InitAsDefaultInstance();
    CMsgSOCacheSubscriptionCheck::default_instance_->InitAsDefaultInstance();
    CMsgSOCacheSubscriptionRefresh::default_instance_->InitAsDefaultInstance();
    CMsgSOCacheVersion::default_instance_->InitAsDefaultInstance();
    CMsgGCMultiplexMessage::default_instance_->InitAsDefaultInstance();
    CGCToGCMsgMasterAck::default_instance_->InitAsDefaultInstance();
    CGCToGCMsgMasterAck_Response::default_instance_->InitAsDefaultInstance();
    CGCToGCMsgMasterStartupComplete::default_instance_->InitAsDefaultInstance();
    CGCToGCMsgMasterStartupComplete_GCInfo::default_instance_->InitAsDefaultInstance();
    CGCToGCMsgRouted::default_instance_->InitAsDefaultInstance();
    CGCToGCMsgRoutedReply::default_instance_->InitAsDefaultInstance();
    CMsgGCUpdateSubGCSessionInfo::default_instance_->InitAsDefaultInstance();
    CMsgGCUpdateSubGCSessionInfo_CMsgUpdate::default_instance_->InitAsDefaultInstance();
    CMsgGCRequestSubGCSessionInfo::default_instance_->InitAsDefaultInstance();
    CMsgGCRequestSubGCSessionInfoResponse::default_instance_->InitAsDefaultInstance();
    CMsgGCToGCIncrementRecruitmentLevel::default_instance_->InitAsDefaultInstance();
    CMsgSOCacheHaveVersion::default_instance_->InitAsDefaultInstance();
    CMsgConnectionStatus::default_instance_->InitAsDefaultInstance();
    CMsgGCToGCSOCacheSubscribe::default_instance_->InitAsDefaultInstance();
    CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions::default_instance_->InitAsDefaultInstance();
    CMsgGCToGCSOCacheUnsubscribe::default_instance_->InitAsDefaultInstance();
    CMsgGCClientPing::default_instance_->InitAsDefaultInstance();
    ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_gcsdk_5fgcmessages_2eproto);
  }
  
  // Force AddDescriptors() to be called at static initialization time.
  struct StaticDescriptorInitializer_gcsdk_5fgcmessages_2eproto {
    StaticDescriptorInitializer_gcsdk_5fgcmessages_2eproto() {
      protobuf_AddDesc_gcsdk_5fgcmessages_2eproto();
    }
  } static_descriptor_initializer_gcsdk_5fgcmessages_2eproto_;
  
  const ::google::protobuf::EnumDescriptor* PartnerAccountType_descriptor() {
    protobuf_AssignDescriptorsOnce();
    return PartnerAccountType_descriptor_;
  }
  bool PartnerAccountType_IsValid(int value) {
    switch(value) {
      case 0:
      case 1:
      case 2:
        return true;
      default:
        return false;
    }
  }
  
  const ::google::protobuf::EnumDescriptor* GCConnectionStatus_descriptor() {
    protobuf_AssignDescriptorsOnce();
    return GCConnectionStatus_descriptor_;
  }
  bool GCConnectionStatus_IsValid(int value) {
    switch(value) {
      case 0:
      case 1:
      case 2:
      case 3:
      case 4:
      case 5:
        return true;
      default:
        return false;
    }
  }
  
  
  // ===================================================================
  
  #ifndef _MSC_VER
  const int CMsgSOIDOwner::kTypeFieldNumber;
  const int CMsgSOIDOwner::kIdFieldNumber;
  #endif  // !_MSC_VER
  
  CMsgSOIDOwner::CMsgSOIDOwner()
    : ::google::protobuf::Message() {
    SharedCtor();
  }
  
  void CMsgSOIDOwner::InitAsDefaultInstance() {
  }
  
  CMsgSOIDOwner::CMsgSOIDOwner(const CMsgSOIDOwner& from)
    : ::google::protobuf::Message() {
    SharedCtor();
    MergeFrom(from);
  }
  
  void CMsgSOIDOwner::SharedCtor() {
    _cached_size_ = 0;
    type_ = 0u;
    id_ = GOOGLE_ULONGLONG(0);
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
  }
  
  CMsgSOIDOwner::~CMsgSOIDOwner() {
    SharedDtor();
  }
  
  void CMsgSOIDOwner::SharedDtor() {
    if (this != default_instance_) {
    }
  }
  
  void CMsgSOIDOwner::SetCachedSize(int size) const {
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
  }
  const ::google::protobuf::Descriptor* CMsgSOIDOwner::descriptor() {
    protobuf_AssignDescriptorsOnce();
    return CMsgSOIDOwner_descriptor_;
  }
  
  const CMsgSOIDOwner& CMsgSOIDOwner::default_instance() {
    if (default_instance_ == NULL) protobuf_AddDesc_gcsdk_5fgcmessages_2eproto();  return *default_instance_;
  }
  
  CMsgSOIDOwner* CMsgSOIDOwner::default_instance_ = NULL;
  
  CMsgSOIDOwner* CMsgSOIDOwner::New() const {
    return new CMsgSOIDOwner;
  }
  
  void CMsgSOIDOwner::Clear() {
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      type_ = 0u;
      id_ = GOOGLE_ULONGLONG(0);
    }
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
    mutable_unknown_fields()->Clear();
  }
  
  bool CMsgSOIDOwner::MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) {
  #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
    ::google::protobuf::uint32 tag;
    while ((tag = input->ReadTag()) != 0) {
      switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
        // optional uint32 type = 1;
        case 1: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                   input, &type_)));
            _set_bit(0);
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectTag(16)) goto parse_id;
          break;
        }
        
        // optional uint64 id = 2;
        case 2: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
           parse_id:
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
                   input, &id_)));
            _set_bit(1);
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectAtEnd()) return true;
          break;
        }
        
        default: {
        handle_uninterpreted:
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
            return true;
          }
          DO_(::google::protobuf::internal::WireFormat::SkipField(
                input, tag, mutable_unknown_fields()));
          break;
        }
      }
    }
    return true;
  #undef DO_
  }
  
  void CMsgSOIDOwner::SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const {
    // optional uint32 type = 1;
    if (_has_bit(0)) {
      ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->type(), output);
    }
    
    // optional uint64 id = 2;
    if (_has_bit(1)) {
      ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->id(), output);
    }
    
    if (!unknown_fields().empty()) {
      ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
          unknown_fields(), output);
    }
  }
  
  ::google::protobuf::uint8* CMsgSOIDOwner::SerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const {
    // optional uint32 type = 1;
    if (_has_bit(0)) {
      target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->type(), target);
    }
    
    // optional uint64 id = 2;
    if (_has_bit(1)) {
      target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->id(), target);
    }
    
    if (!unknown_fields().empty()) {
      target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
          unknown_fields(), target);
    }
    return target;
  }
  
  int CMsgSOIDOwner::ByteSize() const {
    int total_size = 0;
    
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      // optional uint32 type = 1;
      if (has_type()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormatLite::UInt32Size(
            this->type());
      }
      
      // optional uint64 id = 2;
      if (has_id()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormatLite::UInt64Size(
            this->id());
      }
      
    }
    if (!unknown_fields().empty()) {
      total_size +=
        ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
          unknown_fields());
    }
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = total_size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
    return total_size;
  }
  
  void CMsgSOIDOwner::MergeFrom(const ::google::protobuf::Message& from) {
    GOOGLE_CHECK_NE(&from, this);
    const CMsgSOIDOwner* source =
      ::google::protobuf::internal::dynamic_cast_if_available<const CMsgSOIDOwner*>(
        &from);
    if (source == NULL) {
      ::google::protobuf::internal::ReflectionOps::Merge(from, this);
    } else {
      MergeFrom(*source);
    }
  }
  
  void CMsgSOIDOwner::MergeFrom(const CMsgSOIDOwner& from) {
    GOOGLE_CHECK_NE(&from, this);
    if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      if (from._has_bit(0)) {
        set_type(from.type());
      }
      if (from._has_bit(1)) {
        set_id(from.id());
      }
    }
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
  
  void CMsgSOIDOwner::CopyFrom(const ::google::protobuf::Message& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void CMsgSOIDOwner::CopyFrom(const CMsgSOIDOwner& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  bool CMsgSOIDOwner::IsInitialized() const {
    
    return true;
  }
  
  void CMsgSOIDOwner::Swap(CMsgSOIDOwner* other) {
    if (other != this) {
      std::swap(type_, other->type_);
      std::swap(id_, other->id_);
      std::swap(_has_bits_[0], other->_has_bits_[0]);
      _unknown_fields_.Swap(&other->_unknown_fields_);
      std::swap(_cached_size_, other->_cached_size_);
    }
  }
  
  ::google::protobuf::Metadata CMsgSOIDOwner::GetMetadata() const {
    protobuf_AssignDescriptorsOnce();
    ::google::protobuf::Metadata metadata;
    metadata.descriptor = CMsgSOIDOwner_descriptor_;
    metadata.reflection = CMsgSOIDOwner_reflection_;
    return metadata;
  }
  
  
  // ===================================================================
  
  const ::std::string CMsgSOSingleObject::_default_object_data_;
  #ifndef _MSC_VER
  const int CMsgSOSingleObject::kOwnerFieldNumber;
  const int CMsgSOSingleObject::kTypeIdFieldNumber;
  const int CMsgSOSingleObject::kObjectDataFieldNumber;
  const int CMsgSOSingleObject::kVersionFieldNumber;
  const int CMsgSOSingleObject::kOwnerSoidFieldNumber;
  const int CMsgSOSingleObject::kServiceIdFieldNumber;
  #endif  // !_MSC_VER
  
  CMsgSOSingleObject::CMsgSOSingleObject()
    : ::google::protobuf::Message() {
    SharedCtor();
  }
  
  void CMsgSOSingleObject::InitAsDefaultInstance() {
    owner_soid_ = const_cast< ::CMsgSOIDOwner*>(&::CMsgSOIDOwner::default_instance());
  }
  
  CMsgSOSingleObject::CMsgSOSingleObject(const CMsgSOSingleObject& from)
    : ::google::protobuf::Message() {
    SharedCtor();
    MergeFrom(from);
  }
  
  void CMsgSOSingleObject::SharedCtor() {
    _cached_size_ = 0;
    owner_ = GOOGLE_ULONGLONG(0);
    type_id_ = 0;
    object_data_ = const_cast< ::std::string*>(&_default_object_data_);
    version_ = GOOGLE_ULONGLONG(0);
    owner_soid_ = NULL;
    service_id_ = 0u;
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
  }
  
  CMsgSOSingleObject::~CMsgSOSingleObject() {
    SharedDtor();
  }
  
  void CMsgSOSingleObject::SharedDtor() {
    if (object_data_ != &_default_object_data_) {
      delete object_data_;
    }
    if (this != default_instance_) {
      delete owner_soid_;
    }
  }
  
  void CMsgSOSingleObject::SetCachedSize(int size) const {
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
  }
  const ::google::protobuf::Descriptor* CMsgSOSingleObject::descriptor() {
    protobuf_AssignDescriptorsOnce();
    return CMsgSOSingleObject_descriptor_;
  }
  
  const CMsgSOSingleObject& CMsgSOSingleObject::default_instance() {
    if (default_instance_ == NULL) protobuf_AddDesc_gcsdk_5fgcmessages_2eproto();  return *default_instance_;
  }
  
  CMsgSOSingleObject* CMsgSOSingleObject::default_instance_ = NULL;
  
  CMsgSOSingleObject* CMsgSOSingleObject::New() const {
    return new CMsgSOSingleObject;
  }
  
  void CMsgSOSingleObject::Clear() {
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      owner_ = GOOGLE_ULONGLONG(0);
      type_id_ = 0;
      if (_has_bit(2)) {
        if (object_data_ != &_default_object_data_) {
          object_data_->clear();
        }
      }
      version_ = GOOGLE_ULONGLONG(0);
      if (_has_bit(4)) {
        if (owner_soid_ != NULL) owner_soid_->::CMsgSOIDOwner::Clear();
      }
      service_id_ = 0u;
    }
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
    mutable_unknown_fields()->Clear();
  }
  
  bool CMsgSOSingleObject::MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) {
  #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
    ::google::protobuf::uint32 tag;
    while ((tag = input->ReadTag()) != 0) {
      switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
        // optional fixed64 owner = 1;
        case 1: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                   input, &owner_)));
            _set_bit(0);
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectTag(16)) goto parse_type_id;
          break;
        }
        
        // optional int32 type_id = 2;
        case 2: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
           parse_type_id:
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                   input, &type_id_)));
            _set_bit(1);
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectTag(26)) goto parse_object_data;
          break;
        }
        
        // optional bytes object_data = 3;
        case 3: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
           parse_object_data:
            DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                  input, this->mutable_object_data()));
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectTag(33)) goto parse_version;
          break;
        }
        
        // optional fixed64 version = 4;
        case 4: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
           parse_version:
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                   input, &version_)));
            _set_bit(3);
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectTag(42)) goto parse_owner_soid;
          break;
        }
        
        // optional .CMsgSOIDOwner owner_soid = 5;
        case 5: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
           parse_owner_soid:
            DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                 input, mutable_owner_soid()));
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectTag(48)) goto parse_service_id;
          break;
        }
        
        // optional uint32 service_id = 6;
        case 6: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
           parse_service_id:
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                   input, &service_id_)));
            _set_bit(5);
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectAtEnd()) return true;
          break;
        }
        
        default: {
        handle_uninterpreted:
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
            return true;
          }
          DO_(::google::protobuf::internal::WireFormat::SkipField(
                input, tag, mutable_unknown_fields()));
          break;
        }
      }
    }
    return true;
  #undef DO_
  }
  
  void CMsgSOSingleObject::SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const {
    // optional fixed64 owner = 1;
    if (_has_bit(0)) {
      ::google::protobuf::internal::WireFormatLite::WriteFixed64(1, this->owner(), output);
    }
    
    // optional int32 type_id = 2;
    if (_has_bit(1)) {
      ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->type_id(), output);
    }
    
    // optional bytes object_data = 3;
    if (_has_bit(2)) {
      ::google::protobuf::internal::WireFormatLite::WriteBytes(
        3, this->object_data(), output);
    }
    
    // optional fixed64 version = 4;
    if (_has_bit(3)) {
      ::google::protobuf::internal::WireFormatLite::WriteFixed64(4, this->version(), output);
    }
    
    // optional .CMsgSOIDOwner owner_soid = 5;
    if (_has_bit(4)) {
      ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
        5, this->owner_soid(), output);
    }
    
    // optional uint32 service_id = 6;
    if (_has_bit(5)) {
      ::google::protobuf::internal::WireFormatLite::WriteUInt32(6, this->service_id(), output);
    }
    
    if (!unknown_fields().empty()) {
      ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
          unknown_fields(), output);
    }
  }
  
  ::google::protobuf::uint8* CMsgSOSingleObject::SerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const {
    // optional fixed64 owner = 1;
    if (_has_bit(0)) {
      target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(1, this->owner(), target);
    }
    
    // optional int32 type_id = 2;
    if (_has_bit(1)) {
      target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->type_id(), target);
    }
    
    // optional bytes object_data = 3;
    if (_has_bit(2)) {
      target =
        ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
          3, this->object_data(), target);
    }
    
    // optional fixed64 version = 4;
    if (_has_bit(3)) {
      target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(4, this->version(), target);
    }
    
    // optional .CMsgSOIDOwner owner_soid = 5;
    if (_has_bit(4)) {
      target = ::google::protobuf::internal::WireFormatLite::
        WriteMessageNoVirtualToArray(
          5, this->owner_soid(), target);
    }
    
    // optional uint32 service_id = 6;
    if (_has_bit(5)) {
      target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(6, this->service_id(), target);
    }
    
    if (!unknown_fields().empty()) {
      target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
          unknown_fields(), target);
    }
    return target;
  }
  
  int CMsgSOSingleObject::ByteSize() const {
    int total_size = 0;
    
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      // optional fixed64 owner = 1;
      if (has_owner()) {
        total_size += 1 + 8;
      }
      
      // optional int32 type_id = 2;
      if (has_type_id()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormatLite::Int32Size(
            this->type_id());
      }
      
      // optional bytes object_data = 3;
      if (has_object_data()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormatLite::BytesSize(
            this->object_data());
      }
      
      // optional fixed64 version = 4;
      if (has_version()) {
        total_size += 1 + 8;
      }
      
      // optional .CMsgSOIDOwner owner_soid = 5;
      if (has_owner_soid()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
            this->owner_soid());
      }
      
      // optional uint32 service_id = 6;
      if (has_service_id()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormatLite::UInt32Size(
            this->service_id());
      }
      
    }
    if (!unknown_fields().empty()) {
      total_size +=
        ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
          unknown_fields());
    }
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = total_size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
    return total_size;
  }
  
  void CMsgSOSingleObject::MergeFrom(const ::google::protobuf::Message& from) {
    GOOGLE_CHECK_NE(&from, this);
    const CMsgSOSingleObject* source =
      ::google::protobuf::internal::dynamic_cast_if_available<const CMsgSOSingleObject*>(
        &from);
    if (source == NULL) {
      ::google::protobuf::internal::ReflectionOps::Merge(from, this);
    } else {
      MergeFrom(*source);
    }
  }
  
  void CMsgSOSingleObject::MergeFrom(const CMsgSOSingleObject& from) {
    GOOGLE_CHECK_NE(&from, this);
    if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      if (from._has_bit(0)) {
        set_owner(from.owner());
      }
      if (from._has_bit(1)) {
        set_type_id(from.type_id());
      }
      if (from._has_bit(2)) {
        set_object_data(from.object_data());
      }
      if (from._has_bit(3)) {
        set_version(from.version());
      }
      if (from._has_bit(4)) {
        mutable_owner_soid()->::CMsgSOIDOwner::MergeFrom(from.owner_soid());
      }
      if (from._has_bit(5)) {
        set_service_id(from.service_id());
      }
    }
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
  
  void CMsgSOSingleObject::CopyFrom(const ::google::protobuf::Message& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void CMsgSOSingleObject::CopyFrom(const CMsgSOSingleObject& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  bool CMsgSOSingleObject::IsInitialized() const {
    
    return true;
  }
  
  void CMsgSOSingleObject::Swap(CMsgSOSingleObject* other) {
    if (other != this) {
      std::swap(owner_, other->owner_);
      std::swap(type_id_, other->type_id_);
      std::swap(object_data_, other->object_data_);
      std::swap(version_, other->version_);
      std::swap(owner_soid_, other->owner_soid_);
      std::swap(service_id_, other->service_id_);
      std::swap(_has_bits_[0], other->_has_bits_[0]);
      _unknown_fields_.Swap(&other->_unknown_fields_);
      std::swap(_cached_size_, other->_cached_size_);
    }
  }
  
  ::google::protobuf::Metadata CMsgSOSingleObject::GetMetadata() const {
    protobuf_AssignDescriptorsOnce();
    ::google::protobuf::Metadata metadata;
    metadata.descriptor = CMsgSOSingleObject_descriptor_;
    metadata.reflection = CMsgSOSingleObject_reflection_;
    return metadata;
  }
  
  
  // ===================================================================
  
  const ::std::string CMsgSOMultipleObjects_SingleObject::_default_object_data_;
  #ifndef _MSC_VER
  const int CMsgSOMultipleObjects_SingleObject::kTypeIdFieldNumber;
  const int CMsgSOMultipleObjects_SingleObject::kObjectDataFieldNumber;
  #endif  // !_MSC_VER
  
  CMsgSOMultipleObjects_SingleObject::CMsgSOMultipleObjects_SingleObject()
    : ::google::protobuf::Message() {
    SharedCtor();
  }
  
  void CMsgSOMultipleObjects_SingleObject::InitAsDefaultInstance() {
  }
  
  CMsgSOMultipleObjects_SingleObject::CMsgSOMultipleObjects_SingleObject(const CMsgSOMultipleObjects_SingleObject& from)
    : ::google::protobuf::Message() {
    SharedCtor();
    MergeFrom(from);
  }
  
  void CMsgSOMultipleObjects_SingleObject::SharedCtor() {
    _cached_size_ = 0;
    type_id_ = 0;
    object_data_ = const_cast< ::std::string*>(&_default_object_data_);
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
  }
  
  CMsgSOMultipleObjects_SingleObject::~CMsgSOMultipleObjects_SingleObject() {
    SharedDtor();
  }
  
  void CMsgSOMultipleObjects_SingleObject::SharedDtor() {
    if (object_data_ != &_default_object_data_) {
      delete object_data_;
    }
    if (this != default_instance_) {
    }
  }
  
  void CMsgSOMultipleObjects_SingleObject::SetCachedSize(int size) const {
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
  }
  const ::google::protobuf::Descriptor* CMsgSOMultipleObjects_SingleObject::descriptor() {
    protobuf_AssignDescriptorsOnce();
    return CMsgSOMultipleObjects_SingleObject_descriptor_;
  }
  
  const CMsgSOMultipleObjects_SingleObject& CMsgSOMultipleObjects_SingleObject::default_instance() {
    if (default_instance_ == NULL) protobuf_AddDesc_gcsdk_5fgcmessages_2eproto();  return *default_instance_;
  }
  
  CMsgSOMultipleObjects_SingleObject* CMsgSOMultipleObjects_SingleObject::default_instance_ = NULL;
  
  CMsgSOMultipleObjects_SingleObject* CMsgSOMultipleObjects_SingleObject::New() const {
    return new CMsgSOMultipleObjects_SingleObject;
  }
  
  void CMsgSOMultipleObjects_SingleObject::Clear() {
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      type_id_ = 0;
      if (_has_bit(1)) {
        if (object_data_ != &_default_object_data_) {
          object_data_->clear();
        }
      }
    }
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
    mutable_unknown_fields()->Clear();
  }
  
  bool CMsgSOMultipleObjects_SingleObject::MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) {
  #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
    ::google::protobuf::uint32 tag;
    while ((tag = input->ReadTag()) != 0) {
      switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
        // optional int32 type_id = 1;
        case 1: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                   input, &type_id_)));
            _set_bit(0);
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectTag(18)) goto parse_object_data;
          break;
        }
        
        // optional bytes object_data = 2;
        case 2: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
           parse_object_data:
            DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                  input, this->mutable_object_data()));
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectAtEnd()) return true;
          break;
        }
        
        default: {
        handle_uninterpreted:
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
            return true;
          }
          DO_(::google::protobuf::internal::WireFormat::SkipField(
                input, tag, mutable_unknown_fields()));
          break;
        }
      }
    }
    return true;
  #undef DO_
  }
  
  void CMsgSOMultipleObjects_SingleObject::SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const {
    // optional int32 type_id = 1;
    if (_has_bit(0)) {
      ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->type_id(), output);
    }
    
    // optional bytes object_data = 2;
    if (_has_bit(1)) {
      ::google::protobuf::internal::WireFormatLite::WriteBytes(
        2, this->object_data(), output);
    }
    
    if (!unknown_fields().empty()) {
      ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
          unknown_fields(), output);
    }
  }
  
  ::google::protobuf::uint8* CMsgSOMultipleObjects_SingleObject::SerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const {
    // optional int32 type_id = 1;
    if (_has_bit(0)) {
      target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->type_id(), target);
    }
    
    // optional bytes object_data = 2;
    if (_has_bit(1)) {
      target =
        ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
          2, this->object_data(), target);
    }
    
    if (!unknown_fields().empty()) {
      target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
          unknown_fields(), target);
    }
    return target;
  }
  
  int CMsgSOMultipleObjects_SingleObject::ByteSize() const {
    int total_size = 0;
    
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      // optional int32 type_id = 1;
      if (has_type_id()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormatLite::Int32Size(
            this->type_id());
      }
      
      // optional bytes object_data = 2;
      if (has_object_data()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormatLite::BytesSize(
            this->object_data());
      }
      
    }
    if (!unknown_fields().empty()) {
      total_size +=
        ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
          unknown_fields());
    }
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = total_size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
    return total_size;
  }
  
  void CMsgSOMultipleObjects_SingleObject::MergeFrom(const ::google::protobuf::Message& from) {
    GOOGLE_CHECK_NE(&from, this);
    const CMsgSOMultipleObjects_SingleObject* source =
      ::google::protobuf::internal::dynamic_cast_if_available<const CMsgSOMultipleObjects_SingleObject*>(
        &from);
    if (source == NULL) {
      ::google::protobuf::internal::ReflectionOps::Merge(from, this);
    } else {
      MergeFrom(*source);
    }
  }
  
  void CMsgSOMultipleObjects_SingleObject::MergeFrom(const CMsgSOMultipleObjects_SingleObject& from) {
    GOOGLE_CHECK_NE(&from, this);
    if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      if (from._has_bit(0)) {
        set_type_id(from.type_id());
      }
      if (from._has_bit(1)) {
        set_object_data(from.object_data());
      }
    }
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
  
  void CMsgSOMultipleObjects_SingleObject::CopyFrom(const ::google::protobuf::Message& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void CMsgSOMultipleObjects_SingleObject::CopyFrom(const CMsgSOMultipleObjects_SingleObject& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  bool CMsgSOMultipleObjects_SingleObject::IsInitialized() const {
    
    return true;
  }
  
  void CMsgSOMultipleObjects_SingleObject::Swap(CMsgSOMultipleObjects_SingleObject* other) {
    if (other != this) {
      std::swap(type_id_, other->type_id_);
      std::swap(object_data_, other->object_data_);
      std::swap(_has_bits_[0], other->_has_bits_[0]);
      _unknown_fields_.Swap(&other->_unknown_fields_);
      std::swap(_cached_size_, other->_cached_size_);
    }
  }
  
  ::google::protobuf::Metadata CMsgSOMultipleObjects_SingleObject::GetMetadata() const {
    protobuf_AssignDescriptorsOnce();
    ::google::protobuf::Metadata metadata;
    metadata.descriptor = CMsgSOMultipleObjects_SingleObject_descriptor_;
    metadata.reflection = CMsgSOMultipleObjects_SingleObject_reflection_;
    return metadata;
  }
  
  
  // -------------------------------------------------------------------
  
  #ifndef _MSC_VER
  const int CMsgSOMultipleObjects::kOwnerFieldNumber;
  const int CMsgSOMultipleObjects::kObjectsFieldNumber;
  const int CMsgSOMultipleObjects::kVersionFieldNumber;
  const int CMsgSOMultipleObjects::kOwnerSoidFieldNumber;
  const int CMsgSOMultipleObjects::kServiceIdFieldNumber;
  #endif  // !_MSC_VER
  
  CMsgSOMultipleObjects::CMsgSOMultipleObjects()
    : ::google::protobuf::Message() {
    SharedCtor();
  }
  
  void CMsgSOMultipleObjects::InitAsDefaultInstance() {
    owner_soid_ = const_cast< ::CMsgSOIDOwner*>(&::CMsgSOIDOwner::default_instance());
  }
  
  CMsgSOMultipleObjects::CMsgSOMultipleObjects(const CMsgSOMultipleObjects& from)
    : ::google::protobuf::Message() {
    SharedCtor();
    MergeFrom(from);
  }
  
  void CMsgSOMultipleObjects::SharedCtor() {
    _cached_size_ = 0;
    owner_ = GOOGLE_ULONGLONG(0);
    version_ = GOOGLE_ULONGLONG(0);
    owner_soid_ = NULL;
    service_id_ = 0u;
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
  }
  
  CMsgSOMultipleObjects::~CMsgSOMultipleObjects() {
    SharedDtor();
  }
  
  void CMsgSOMultipleObjects::SharedDtor() {
    if (this != default_instance_) {
      delete owner_soid_;
    }
  }
  
  void CMsgSOMultipleObjects::SetCachedSize(int size) const {
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
  }
  const ::google::protobuf::Descriptor* CMsgSOMultipleObjects::descriptor() {
    protobuf_AssignDescriptorsOnce();
    return CMsgSOMultipleObjects_descriptor_;
  }
  
  const CMsgSOMultipleObjects& CMsgSOMultipleObjects::default_instance() {
    if (default_instance_ == NULL) protobuf_AddDesc_gcsdk_5fgcmessages_2eproto();  return *default_instance_;
  }
  
  CMsgSOMultipleObjects* CMsgSOMultipleObjects::default_instance_ = NULL;
  
  CMsgSOMultipleObjects* CMsgSOMultipleObjects::New() const {
    return new CMsgSOMultipleObjects;
  }
  
  void CMsgSOMultipleObjects::Clear() {
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      owner_ = GOOGLE_ULONGLONG(0);
      version_ = GOOGLE_ULONGLONG(0);
      if (_has_bit(3)) {
        if (owner_soid_ != NULL) owner_soid_->::CMsgSOIDOwner::Clear();
      }
      service_id_ = 0u;
    }
    objects_.Clear();
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
    mutable_unknown_fields()->Clear();
  }
  
  bool CMsgSOMultipleObjects::MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) {
  #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
    ::google::protobuf::uint32 tag;
    while ((tag = input->ReadTag()) != 0) {
      switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
        // optional fixed64 owner = 1;
        case 1: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                   input, &owner_)));
            _set_bit(0);
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectTag(18)) goto parse_objects;
          break;
        }
        
        // repeated .CMsgSOMultipleObjects.SingleObject objects = 2;
        case 2: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
           parse_objects:
            DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                  input, add_objects()));
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectTag(18)) goto parse_objects;
          if (input->ExpectTag(25)) goto parse_version;
          break;
        }
        
        // optional fixed64 version = 3;
        case 3: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
           parse_version:
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                   input, &version_)));
            _set_bit(2);
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectTag(50)) goto parse_owner_soid;
          break;
        }
        
        // optional .CMsgSOIDOwner owner_soid = 6;
        case 6: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
           parse_owner_soid:
            DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                 input, mutable_owner_soid()));
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectTag(56)) goto parse_service_id;
          break;
        }
        
        // optional uint32 service_id = 7;
        case 7: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
           parse_service_id:
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                   input, &service_id_)));
            _set_bit(4);
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectAtEnd()) return true;
          break;
        }
        
        default: {
        handle_uninterpreted:
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
            return true;
          }
          DO_(::google::protobuf::internal::WireFormat::SkipField(
                input, tag, mutable_unknown_fields()));
          break;
        }
      }
    }
    return true;
  #undef DO_
  }
  
  void CMsgSOMultipleObjects::SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const {
    // optional fixed64 owner = 1;
    if (_has_bit(0)) {
      ::google::protobuf::internal::WireFormatLite::WriteFixed64(1, this->owner(), output);
    }
    
    // repeated .CMsgSOMultipleObjects.SingleObject objects = 2;
    for (int i = 0; i < this->objects_size(); i++) {
      ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
        2, this->objects(i), output);
    }
    
    // optional fixed64 version = 3;
    if (_has_bit(2)) {
      ::google::protobuf::internal::WireFormatLite::WriteFixed64(3, this->version(), output);
    }
    
    // optional .CMsgSOIDOwner owner_soid = 6;
    if (_has_bit(3)) {
      ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
        6, this->owner_soid(), output);
    }
    
    // optional uint32 service_id = 7;
    if (_has_bit(4)) {
      ::google::protobuf::internal::WireFormatLite::WriteUInt32(7, this->service_id(), output);
    }
    
    if (!unknown_fields().empty()) {
      ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
          unknown_fields(), output);
    }
  }
  
  ::google::protobuf::uint8* CMsgSOMultipleObjects::SerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const {
    // optional fixed64 owner = 1;
    if (_has_bit(0)) {
      target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(1, this->owner(), target);
    }
    
    // repeated .CMsgSOMultipleObjects.SingleObject objects = 2;
    for (int i = 0; i < this->objects_size(); i++) {
      target = ::google::protobuf::internal::WireFormatLite::
        WriteMessageNoVirtualToArray(
          2, this->objects(i), target);
    }
    
    // optional fixed64 version = 3;
    if (_has_bit(2)) {
      target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(3, this->version(), target);
    }
    
    // optional .CMsgSOIDOwner owner_soid = 6;
    if (_has_bit(3)) {
      target = ::google::protobuf::internal::WireFormatLite::
        WriteMessageNoVirtualToArray(
          6, this->owner_soid(), target);
    }
    
    // optional uint32 service_id = 7;
    if (_has_bit(4)) {
      target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(7, this->service_id(), target);
    }
    
    if (!unknown_fields().empty()) {
      target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
          unknown_fields(), target);
    }
    return target;
  }
  
  int CMsgSOMultipleObjects::ByteSize() const {
    int total_size = 0;
    
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      // optional fixed64 owner = 1;
      if (has_owner()) {
        total_size += 1 + 8;
      }
      
      // optional fixed64 version = 3;
      if (has_version()) {
        total_size += 1 + 8;
      }
      
      // optional .CMsgSOIDOwner owner_soid = 6;
      if (has_owner_soid()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
            this->owner_soid());
      }
      
      // optional uint32 service_id = 7;
      if (has_service_id()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormatLite::UInt32Size(
            this->service_id());
      }
      
    }
    // repeated .CMsgSOMultipleObjects.SingleObject objects = 2;
    total_size += 1 * this->objects_size();
    for (int i = 0; i < this->objects_size(); i++) {
      total_size +=
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->objects(i));
    }
    
    if (!unknown_fields().empty()) {
      total_size +=
        ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
          unknown_fields());
    }
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = total_size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
    return total_size;
  }
  
  void CMsgSOMultipleObjects::MergeFrom(const ::google::protobuf::Message& from) {
    GOOGLE_CHECK_NE(&from, this);
    const CMsgSOMultipleObjects* source =
      ::google::protobuf::internal::dynamic_cast_if_available<const CMsgSOMultipleObjects*>(
        &from);
    if (source == NULL) {
      ::google::protobuf::internal::ReflectionOps::Merge(from, this);
    } else {
      MergeFrom(*source);
    }
  }
  
  void CMsgSOMultipleObjects::MergeFrom(const CMsgSOMultipleObjects& from) {
    GOOGLE_CHECK_NE(&from, this);
    objects_.MergeFrom(from.objects_);
    if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      if (from._has_bit(0)) {
        set_owner(from.owner());
      }
      if (from._has_bit(2)) {
        set_version(from.version());
      }
      if (from._has_bit(3)) {
        mutable_owner_soid()->::CMsgSOIDOwner::MergeFrom(from.owner_soid());
      }
      if (from._has_bit(4)) {
        set_service_id(from.service_id());
      }
    }
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
  
  void CMsgSOMultipleObjects::CopyFrom(const ::google::protobuf::Message& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void CMsgSOMultipleObjects::CopyFrom(const CMsgSOMultipleObjects& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  bool CMsgSOMultipleObjects::IsInitialized() const {
    
    return true;
  }
  
  void CMsgSOMultipleObjects::Swap(CMsgSOMultipleObjects* other) {
    if (other != this) {
      std::swap(owner_, other->owner_);
      objects_.Swap(&other->objects_);
      std::swap(version_, other->version_);
      std::swap(owner_soid_, other->owner_soid_);
      std::swap(service_id_, other->service_id_);
      std::swap(_has_bits_[0], other->_has_bits_[0]);
      _unknown_fields_.Swap(&other->_unknown_fields_);
      std::swap(_cached_size_, other->_cached_size_);
    }
  }
  
  ::google::protobuf::Metadata CMsgSOMultipleObjects::GetMetadata() const {
    protobuf_AssignDescriptorsOnce();
    ::google::protobuf::Metadata metadata;
    metadata.descriptor = CMsgSOMultipleObjects_descriptor_;
    metadata.reflection = CMsgSOMultipleObjects_reflection_;
    return metadata;
  }
  
  
  // ===================================================================
  
  #ifndef _MSC_VER
  const int CMsgSOCacheSubscribed_SubscribedType::kTypeIdFieldNumber;
  const int CMsgSOCacheSubscribed_SubscribedType::kObjectDataFieldNumber;
  #endif  // !_MSC_VER
  
  CMsgSOCacheSubscribed_SubscribedType::CMsgSOCacheSubscribed_SubscribedType()
    : ::google::protobuf::Message() {
    SharedCtor();
  }
  
  void CMsgSOCacheSubscribed_SubscribedType::InitAsDefaultInstance() {
  }
  
  CMsgSOCacheSubscribed_SubscribedType::CMsgSOCacheSubscribed_SubscribedType(const CMsgSOCacheSubscribed_SubscribedType& from)
    : ::google::protobuf::Message() {
    SharedCtor();
    MergeFrom(from);
  }
  
  void CMsgSOCacheSubscribed_SubscribedType::SharedCtor() {
    _cached_size_ = 0;
    type_id_ = 0;
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
  }
  
  CMsgSOCacheSubscribed_SubscribedType::~CMsgSOCacheSubscribed_SubscribedType() {
    SharedDtor();
  }
  
  void CMsgSOCacheSubscribed_SubscribedType::SharedDtor() {
    if (this != default_instance_) {
    }
  }
  
  void CMsgSOCacheSubscribed_SubscribedType::SetCachedSize(int size) const {
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
  }
  const ::google::protobuf::Descriptor* CMsgSOCacheSubscribed_SubscribedType::descriptor() {
    protobuf_AssignDescriptorsOnce();
    return CMsgSOCacheSubscribed_SubscribedType_descriptor_;
  }
  
  const CMsgSOCacheSubscribed_SubscribedType& CMsgSOCacheSubscribed_SubscribedType::default_instance() {
    if (default_instance_ == NULL) protobuf_AddDesc_gcsdk_5fgcmessages_2eproto();  return *default_instance_;
  }
  
  CMsgSOCacheSubscribed_SubscribedType* CMsgSOCacheSubscribed_SubscribedType::default_instance_ = NULL;
  
  CMsgSOCacheSubscribed_SubscribedType* CMsgSOCacheSubscribed_SubscribedType::New() const {
    return new CMsgSOCacheSubscribed_SubscribedType;
  }
  
  void CMsgSOCacheSubscribed_SubscribedType::Clear() {
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      type_id_ = 0;
    }
    object_data_.Clear();
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
    mutable_unknown_fields()->Clear();
  }
  
  bool CMsgSOCacheSubscribed_SubscribedType::MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) {
  #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
    ::google::protobuf::uint32 tag;
    while ((tag = input->ReadTag()) != 0) {
      switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
        // optional int32 type_id = 1;
        case 1: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                   input, &type_id_)));
            _set_bit(0);
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectTag(18)) goto parse_object_data;
          break;
        }
        
        // repeated bytes object_data = 2;
        case 2: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
           parse_object_data:
            DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                  input, this->add_object_data()));
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectTag(18)) goto parse_object_data;
          if (input->ExpectAtEnd()) return true;
          break;
        }
        
        default: {
        handle_uninterpreted:
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
            return true;
          }
          DO_(::google::protobuf::internal::WireFormat::SkipField(
                input, tag, mutable_unknown_fields()));
          break;
        }
      }
    }
    return true;
  #undef DO_
  }
  
  void CMsgSOCacheSubscribed_SubscribedType::SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const {
    // optional int32 type_id = 1;
    if (_has_bit(0)) {
      ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->type_id(), output);
    }
    
    // repeated bytes object_data = 2;
    for (int i = 0; i < this->object_data_size(); i++) {
      ::google::protobuf::internal::WireFormatLite::WriteBytes(
        2, this->object_data(i), output);
    }
    
    if (!unknown_fields().empty()) {
      ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
          unknown_fields(), output);
    }
  }
  
  ::google::protobuf::uint8* CMsgSOCacheSubscribed_SubscribedType::SerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const {
    // optional int32 type_id = 1;
    if (_has_bit(0)) {
      target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->type_id(), target);
    }
    
    // repeated bytes object_data = 2;
    for (int i = 0; i < this->object_data_size(); i++) {
      target = ::google::protobuf::internal::WireFormatLite::
        WriteBytesToArray(2, this->object_data(i), target);
    }
    
    if (!unknown_fields().empty()) {
      target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
          unknown_fields(), target);
    }
    return target;
  }
  
  int CMsgSOCacheSubscribed_SubscribedType::ByteSize() const {
    int total_size = 0;
    
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      // optional int32 type_id = 1;
      if (has_type_id()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormatLite::Int32Size(
            this->type_id());
      }
      
    }
    // repeated bytes object_data = 2;
    total_size += 1 * this->object_data_size();
    for (int i = 0; i < this->object_data_size(); i++) {
      total_size += ::google::protobuf::internal::WireFormatLite::BytesSize(
        this->object_data(i));
    }
    
    if (!unknown_fields().empty()) {
      total_size +=
        ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
          unknown_fields());
    }
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = total_size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
    return total_size;
  }
  
  void CMsgSOCacheSubscribed_SubscribedType::MergeFrom(const ::google::protobuf::Message& from) {
    GOOGLE_CHECK_NE(&from, this);
    const CMsgSOCacheSubscribed_SubscribedType* source =
      ::google::protobuf::internal::dynamic_cast_if_available<const CMsgSOCacheSubscribed_SubscribedType*>(
        &from);
    if (source == NULL) {
      ::google::protobuf::internal::ReflectionOps::Merge(from, this);
    } else {
      MergeFrom(*source);
    }
  }
  
  void CMsgSOCacheSubscribed_SubscribedType::MergeFrom(const CMsgSOCacheSubscribed_SubscribedType& from) {
    GOOGLE_CHECK_NE(&from, this);
    object_data_.MergeFrom(from.object_data_);
    if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      if (from._has_bit(0)) {
        set_type_id(from.type_id());
      }
    }
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
  
  void CMsgSOCacheSubscribed_SubscribedType::CopyFrom(const ::google::protobuf::Message& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void CMsgSOCacheSubscribed_SubscribedType::CopyFrom(const CMsgSOCacheSubscribed_SubscribedType& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  bool CMsgSOCacheSubscribed_SubscribedType::IsInitialized() const {
    
    return true;
  }
  
  void CMsgSOCacheSubscribed_SubscribedType::Swap(CMsgSOCacheSubscribed_SubscribedType* other) {
    if (other != this) {
      std::swap(type_id_, other->type_id_);
      object_data_.Swap(&other->object_data_);
      std::swap(_has_bits_[0], other->_has_bits_[0]);
      _unknown_fields_.Swap(&other->_unknown_fields_);
      std::swap(_cached_size_, other->_cached_size_);
    }
  }
  
  ::google::protobuf::Metadata CMsgSOCacheSubscribed_SubscribedType::GetMetadata() const {
    protobuf_AssignDescriptorsOnce();
    ::google::protobuf::Metadata metadata;
    metadata.descriptor = CMsgSOCacheSubscribed_SubscribedType_descriptor_;
    metadata.reflection = CMsgSOCacheSubscribed_SubscribedType_reflection_;
    return metadata;
  }
  
  
  // -------------------------------------------------------------------
  
  #ifndef _MSC_VER
  const int CMsgSOCacheSubscribed::kOwnerFieldNumber;
  const int CMsgSOCacheSubscribed::kObjectsFieldNumber;
  const int CMsgSOCacheSubscribed::kVersionFieldNumber;
  const int CMsgSOCacheSubscribed::kOwnerSoidFieldNumber;
  const int CMsgSOCacheSubscribed::kServiceIdFieldNumber;
  const int CMsgSOCacheSubscribed::kServiceListFieldNumber;
  const int CMsgSOCacheSubscribed::kSyncVersionFieldNumber;
  #endif  // !_MSC_VER
  
  CMsgSOCacheSubscribed::CMsgSOCacheSubscribed()
    : ::google::protobuf::Message() {
    SharedCtor();
  }
  
  void CMsgSOCacheSubscribed::InitAsDefaultInstance() {
    owner_soid_ = const_cast< ::CMsgSOIDOwner*>(&::CMsgSOIDOwner::default_instance());
  }
  
  CMsgSOCacheSubscribed::CMsgSOCacheSubscribed(const CMsgSOCacheSubscribed& from)
    : ::google::protobuf::Message() {
    SharedCtor();
    MergeFrom(from);
  }
  
  void CMsgSOCacheSubscribed::SharedCtor() {
    _cached_size_ = 0;
    owner_ = GOOGLE_ULONGLONG(0);
    version_ = GOOGLE_ULONGLONG(0);
    owner_soid_ = NULL;
    service_id_ = 0u;
    sync_version_ = GOOGLE_ULONGLONG(0);
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
  }
  
  CMsgSOCacheSubscribed::~CMsgSOCacheSubscribed() {
    SharedDtor();
  }
  
  void CMsgSOCacheSubscribed::SharedDtor() {
    if (this != default_instance_) {
      delete owner_soid_;
    }
  }
  
  void CMsgSOCacheSubscribed::SetCachedSize(int size) const {
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
  }
  const ::google::protobuf::Descriptor* CMsgSOCacheSubscribed::descriptor() {
    protobuf_AssignDescriptorsOnce();
    return CMsgSOCacheSubscribed_descriptor_;
  }
  
  const CMsgSOCacheSubscribed& CMsgSOCacheSubscribed::default_instance() {
    if (default_instance_ == NULL) protobuf_AddDesc_gcsdk_5fgcmessages_2eproto();  return *default_instance_;
  }
  
  CMsgSOCacheSubscribed* CMsgSOCacheSubscribed::default_instance_ = NULL;
  
  CMsgSOCacheSubscribed* CMsgSOCacheSubscribed::New() const {
    return new CMsgSOCacheSubscribed;
  }
  
  void CMsgSOCacheSubscribed::Clear() {
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      owner_ = GOOGLE_ULONGLONG(0);
      version_ = GOOGLE_ULONGLONG(0);
      if (_has_bit(3)) {
        if (owner_soid_ != NULL) owner_soid_->::CMsgSOIDOwner::Clear();
      }
      service_id_ = 0u;
      sync_version_ = GOOGLE_ULONGLONG(0);
    }
    objects_.Clear();
    service_list_.Clear();
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
    mutable_unknown_fields()->Clear();
  }
  
  bool CMsgSOCacheSubscribed::MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) {
  #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
    ::google::protobuf::uint32 tag;
    while ((tag = input->ReadTag()) != 0) {
      switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
        // optional fixed64 owner = 1;
        case 1: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                   input, &owner_)));
            _set_bit(0);
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectTag(18)) goto parse_objects;
          break;
        }
        
        // repeated .CMsgSOCacheSubscribed.SubscribedType objects = 2;
        case 2: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
           parse_objects:
            DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                  input, add_objects()));
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectTag(18)) goto parse_objects;
          if (input->ExpectTag(25)) goto parse_version;
          break;
        }
        
        // optional fixed64 version = 3;
        case 3: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
           parse_version:
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                   input, &version_)));
            _set_bit(2);
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectTag(34)) goto parse_owner_soid;
          break;
        }
        
        // optional .CMsgSOIDOwner owner_soid = 4;
        case 4: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
           parse_owner_soid:
            DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                 input, mutable_owner_soid()));
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectTag(40)) goto parse_service_id;
          break;
        }
        
        // optional uint32 service_id = 5;
        case 5: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
           parse_service_id:
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                   input, &service_id_)));
            _set_bit(4);
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectTag(48)) goto parse_service_list;
          break;
        }
        
        // repeated uint32 service_list = 6;
        case 6: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
           parse_service_list:
            DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                     ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                   1, 48, input, this->mutable_service_list())));
          } else if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag)
                     == ::google::protobuf::internal::WireFormatLite::
                        WIRETYPE_LENGTH_DELIMITED) {
            DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                     ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                   input, this->mutable_service_list())));
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectTag(48)) goto parse_service_list;
          if (input->ExpectTag(57)) goto parse_sync_version;
          break;
        }
        
        // optional fixed64 sync_version = 7;
        case 7: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
           parse_sync_version:
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                   input, &sync_version_)));
            _set_bit(6);
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectAtEnd()) return true;
          break;
        }
        
        default: {
        handle_uninterpreted:
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
            return true;
          }
          DO_(::google::protobuf::internal::WireFormat::SkipField(
                input, tag, mutable_unknown_fields()));
          break;
        }
      }
    }
    return true;
  #undef DO_
  }
  
  void CMsgSOCacheSubscribed::SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const {
    // optional fixed64 owner = 1;
    if (_has_bit(0)) {
      ::google::protobuf::internal::WireFormatLite::WriteFixed64(1, this->owner(), output);
    }
    
    // repeated .CMsgSOCacheSubscribed.SubscribedType objects = 2;
    for (int i = 0; i < this->objects_size(); i++) {
      ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
        2, this->objects(i), output);
    }
    
    // optional fixed64 version = 3;
    if (_has_bit(2)) {
      ::google::protobuf::internal::WireFormatLite::WriteFixed64(3, this->version(), output);
    }
    
    // optional .CMsgSOIDOwner owner_soid = 4;
    if (_has_bit(3)) {
      ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
        4, this->owner_soid(), output);
    }
    
    // optional uint32 service_id = 5;
    if (_has_bit(4)) {
      ::google::protobuf::internal::WireFormatLite::WriteUInt32(5, this->service_id(), output);
    }
    
    // repeated uint32 service_list = 6;
    for (int i = 0; i < this->service_list_size(); i++) {
      ::google::protobuf::internal::WireFormatLite::WriteUInt32(
        6, this->service_list(i), output);
    }
    
    // optional fixed64 sync_version = 7;
    if (_has_bit(6)) {
      ::google::protobuf::internal::WireFormatLite::WriteFixed64(7, this->sync_version(), output);
    }
    
    if (!unknown_fields().empty()) {
      ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
          unknown_fields(), output);
    }
  }
  
  ::google::protobuf::uint8* CMsgSOCacheSubscribed::SerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const {
    // optional fixed64 owner = 1;
    if (_has_bit(0)) {
      target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(1, this->owner(), target);
    }
    
    // repeated .CMsgSOCacheSubscribed.SubscribedType objects = 2;
    for (int i = 0; i < this->objects_size(); i++) {
      target = ::google::protobuf::internal::WireFormatLite::
        WriteMessageNoVirtualToArray(
          2, this->objects(i), target);
    }
    
    // optional fixed64 version = 3;
    if (_has_bit(2)) {
      target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(3, this->version(), target);
    }
    
    // optional .CMsgSOIDOwner owner_soid = 4;
    if (_has_bit(3)) {
      target = ::google::protobuf::internal::WireFormatLite::
        WriteMessageNoVirtualToArray(
          4, this->owner_soid(), target);
    }
    
    // optional uint32 service_id = 5;
    if (_has_bit(4)) {
      target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(5, this->service_id(), target);
    }
    
    // repeated uint32 service_list = 6;
    for (int i = 0; i < this->service_list_size(); i++) {
      target = ::google::protobuf::internal::WireFormatLite::
        WriteUInt32ToArray(6, this->service_list(i), target);
    }
    
    // optional fixed64 sync_version = 7;
    if (_has_bit(6)) {
      target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(7, this->sync_version(), target);
    }
    
    if (!unknown_fields().empty()) {
      target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
          unknown_fields(), target);
    }
    return target;
  }
  
  int CMsgSOCacheSubscribed::ByteSize() const {
    int total_size = 0;
    
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      // optional fixed64 owner = 1;
      if (has_owner()) {
        total_size += 1 + 8;
      }
      
      // optional fixed64 version = 3;
      if (has_version()) {
        total_size += 1 + 8;
      }
      
      // optional .CMsgSOIDOwner owner_soid = 4;
      if (has_owner_soid()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
            this->owner_soid());
      }
      
      // optional uint32 service_id = 5;
      if (has_service_id()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormatLite::UInt32Size(
            this->service_id());
      }
      
      // optional fixed64 sync_version = 7;
      if (has_sync_version()) {
        total_size += 1 + 8;
      }
      
    }
    // repeated .CMsgSOCacheSubscribed.SubscribedType objects = 2;
    total_size += 1 * this->objects_size();
    for (int i = 0; i < this->objects_size(); i++) {
      total_size +=
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->objects(i));
    }
    
    // repeated uint32 service_list = 6;
    {
      int data_size = 0;
      for (int i = 0; i < this->service_list_size(); i++) {
        data_size += ::google::protobuf::internal::WireFormatLite::
          UInt32Size(this->service_list(i));
      }
      total_size += 1 * this->service_list_size() + data_size;
    }
    
    if (!unknown_fields().empty()) {
      total_size +=
        ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
          unknown_fields());
    }
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = total_size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
    return total_size;
  }
  
  void CMsgSOCacheSubscribed::MergeFrom(const ::google::protobuf::Message& from) {
    GOOGLE_CHECK_NE(&from, this);
    const CMsgSOCacheSubscribed* source =
      ::google::protobuf::internal::dynamic_cast_if_available<const CMsgSOCacheSubscribed*>(
        &from);
    if (source == NULL) {
      ::google::protobuf::internal::ReflectionOps::Merge(from, this);
    } else {
      MergeFrom(*source);
    }
  }
  
  void CMsgSOCacheSubscribed::MergeFrom(const CMsgSOCacheSubscribed& from) {
    GOOGLE_CHECK_NE(&from, this);
    objects_.MergeFrom(from.objects_);
    service_list_.MergeFrom(from.service_list_);
    if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      if (from._has_bit(0)) {
        set_owner(from.owner());
      }
      if (from._has_bit(2)) {
        set_version(from.version());
      }
      if (from._has_bit(3)) {
        mutable_owner_soid()->::CMsgSOIDOwner::MergeFrom(from.owner_soid());
      }
      if (from._has_bit(4)) {
        set_service_id(from.service_id());
      }
      if (from._has_bit(6)) {
        set_sync_version(from.sync_version());
      }
    }
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
  
  void CMsgSOCacheSubscribed::CopyFrom(const ::google::protobuf::Message& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void CMsgSOCacheSubscribed::CopyFrom(const CMsgSOCacheSubscribed& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  bool CMsgSOCacheSubscribed::IsInitialized() const {
    
    return true;
  }
  
  void CMsgSOCacheSubscribed::Swap(CMsgSOCacheSubscribed* other) {
    if (other != this) {
      std::swap(owner_, other->owner_);
      objects_.Swap(&other->objects_);
      std::swap(version_, other->version_);
      std::swap(owner_soid_, other->owner_soid_);
      std::swap(service_id_, other->service_id_);
      service_list_.Swap(&other->service_list_);
      std::swap(sync_version_, other->sync_version_);
      std::swap(_has_bits_[0], other->_has_bits_[0]);
      _unknown_fields_.Swap(&other->_unknown_fields_);
      std::swap(_cached_size_, other->_cached_size_);
    }
  }
  
  ::google::protobuf::Metadata CMsgSOCacheSubscribed::GetMetadata() const {
    protobuf_AssignDescriptorsOnce();
    ::google::protobuf::Metadata metadata;
    metadata.descriptor = CMsgSOCacheSubscribed_descriptor_;
    metadata.reflection = CMsgSOCacheSubscribed_reflection_;
    return metadata;
  }
  
  
  // ===================================================================
  
  #ifndef _MSC_VER
  const int CMsgSOCacheSubscribedUpToDate::kVersionFieldNumber;
  const int CMsgSOCacheSubscribedUpToDate::kOwnerSoidFieldNumber;
  const int CMsgSOCacheSubscribedUpToDate::kServiceIdFieldNumber;
  const int CMsgSOCacheSubscribedUpToDate::kServiceListFieldNumber;
  const int CMsgSOCacheSubscribedUpToDate::kSyncVersionFieldNumber;
  #endif  // !_MSC_VER
  
  CMsgSOCacheSubscribedUpToDate::CMsgSOCacheSubscribedUpToDate()
    : ::google::protobuf::Message() {
    SharedCtor();
  }
  
  void CMsgSOCacheSubscribedUpToDate::InitAsDefaultInstance() {
    owner_soid_ = const_cast< ::CMsgSOIDOwner*>(&::CMsgSOIDOwner::default_instance());
  }
  
  CMsgSOCacheSubscribedUpToDate::CMsgSOCacheSubscribedUpToDate(const CMsgSOCacheSubscribedUpToDate& from)
    : ::google::protobuf::Message() {
    SharedCtor();
    MergeFrom(from);
  }
  
  void CMsgSOCacheSubscribedUpToDate::SharedCtor() {
    _cached_size_ = 0;
    version_ = GOOGLE_ULONGLONG(0);
    owner_soid_ = NULL;
    service_id_ = 0u;
    sync_version_ = GOOGLE_ULONGLONG(0);
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
  }
  
  CMsgSOCacheSubscribedUpToDate::~CMsgSOCacheSubscribedUpToDate() {
    SharedDtor();
  }
  
  void CMsgSOCacheSubscribedUpToDate::SharedDtor() {
    if (this != default_instance_) {
      delete owner_soid_;
    }
  }
  
  void CMsgSOCacheSubscribedUpToDate::SetCachedSize(int size) const {
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
  }
  const ::google::protobuf::Descriptor* CMsgSOCacheSubscribedUpToDate::descriptor() {
    protobuf_AssignDescriptorsOnce();
    return CMsgSOCacheSubscribedUpToDate_descriptor_;
  }
  
  const CMsgSOCacheSubscribedUpToDate& CMsgSOCacheSubscribedUpToDate::default_instance() {
    if (default_instance_ == NULL) protobuf_AddDesc_gcsdk_5fgcmessages_2eproto();  return *default_instance_;
  }
  
  CMsgSOCacheSubscribedUpToDate* CMsgSOCacheSubscribedUpToDate::default_instance_ = NULL;
  
  CMsgSOCacheSubscribedUpToDate* CMsgSOCacheSubscribedUpToDate::New() const {
    return new CMsgSOCacheSubscribedUpToDate;
  }
  
  void CMsgSOCacheSubscribedUpToDate::Clear() {
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      version_ = GOOGLE_ULONGLONG(0);
      if (_has_bit(1)) {
        if (owner_soid_ != NULL) owner_soid_->::CMsgSOIDOwner::Clear();
      }
      service_id_ = 0u;
      sync_version_ = GOOGLE_ULONGLONG(0);
    }
    service_list_.Clear();
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
    mutable_unknown_fields()->Clear();
  }
  
  bool CMsgSOCacheSubscribedUpToDate::MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) {
  #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
    ::google::protobuf::uint32 tag;
    while ((tag = input->ReadTag()) != 0) {
      switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
        // optional fixed64 version = 1;
        case 1: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                   input, &version_)));
            _set_bit(0);
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectTag(18)) goto parse_owner_soid;
          break;
        }
        
        // optional .CMsgSOIDOwner owner_soid = 2;
        case 2: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
           parse_owner_soid:
            DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                 input, mutable_owner_soid()));
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectTag(24)) goto parse_service_id;
          break;
        }
        
        // optional uint32 service_id = 3;
        case 3: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
           parse_service_id:
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                   input, &service_id_)));
            _set_bit(2);
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectTag(32)) goto parse_service_list;
          break;
        }
        
        // repeated uint32 service_list = 4;
        case 4: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
           parse_service_list:
            DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                     ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                   1, 32, input, this->mutable_service_list())));
          } else if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag)
                     == ::google::protobuf::internal::WireFormatLite::
                        WIRETYPE_LENGTH_DELIMITED) {
            DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                     ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                   input, this->mutable_service_list())));
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectTag(32)) goto parse_service_list;
          if (input->ExpectTag(41)) goto parse_sync_version;
          break;
        }
        
        // optional fixed64 sync_version = 5;
        case 5: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
           parse_sync_version:
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                   input, &sync_version_)));
            _set_bit(4);
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectAtEnd()) return true;
          break;
        }
        
        default: {
        handle_uninterpreted:
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
            return true;
          }
          DO_(::google::protobuf::internal::WireFormat::SkipField(
                input, tag, mutable_unknown_fields()));
          break;
        }
      }
    }
    return true;
  #undef DO_
  }
  
  void CMsgSOCacheSubscribedUpToDate::SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const {
    // optional fixed64 version = 1;
    if (_has_bit(0)) {
      ::google::protobuf::internal::WireFormatLite::WriteFixed64(1, this->version(), output);
    }
    
    // optional .CMsgSOIDOwner owner_soid = 2;
    if (_has_bit(1)) {
      ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
        2, this->owner_soid(), output);
    }
    
    // optional uint32 service_id = 3;
    if (_has_bit(2)) {
      ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->service_id(), output);
    }
    
    // repeated uint32 service_list = 4;
    for (int i = 0; i < this->service_list_size(); i++) {
      ::google::protobuf::internal::WireFormatLite::WriteUInt32(
        4, this->service_list(i), output);
    }
    
    // optional fixed64 sync_version = 5;
    if (_has_bit(4)) {
      ::google::protobuf::internal::WireFormatLite::WriteFixed64(5, this->sync_version(), output);
    }
    
    if (!unknown_fields().empty()) {
      ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
          unknown_fields(), output);
    }
  }
  
  ::google::protobuf::uint8* CMsgSOCacheSubscribedUpToDate::SerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const {
    // optional fixed64 version = 1;
    if (_has_bit(0)) {
      target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(1, this->version(), target);
    }
    
    // optional .CMsgSOIDOwner owner_soid = 2;
    if (_has_bit(1)) {
      target = ::google::protobuf::internal::WireFormatLite::
        WriteMessageNoVirtualToArray(
          2, this->owner_soid(), target);
    }
    
    // optional uint32 service_id = 3;
    if (_has_bit(2)) {
      target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->service_id(), target);
    }
    
    // repeated uint32 service_list = 4;
    for (int i = 0; i < this->service_list_size(); i++) {
      target = ::google::protobuf::internal::WireFormatLite::
        WriteUInt32ToArray(4, this->service_list(i), target);
    }
    
    // optional fixed64 sync_version = 5;
    if (_has_bit(4)) {
      target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(5, this->sync_version(), target);
    }
    
    if (!unknown_fields().empty()) {
      target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
          unknown_fields(), target);
    }
    return target;
  }
  
  int CMsgSOCacheSubscribedUpToDate::ByteSize() const {
    int total_size = 0;
    
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      // optional fixed64 version = 1;
      if (has_version()) {
        total_size += 1 + 8;
      }
      
      // optional .CMsgSOIDOwner owner_soid = 2;
      if (has_owner_soid()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
            this->owner_soid());
      }
      
      // optional uint32 service_id = 3;
      if (has_service_id()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormatLite::UInt32Size(
            this->service_id());
      }
      
      // optional fixed64 sync_version = 5;
      if (has_sync_version()) {
        total_size += 1 + 8;
      }
      
    }
    // repeated uint32 service_list = 4;
    {
      int data_size = 0;
      for (int i = 0; i < this->service_list_size(); i++) {
        data_size += ::google::protobuf::internal::WireFormatLite::
          UInt32Size(this->service_list(i));
      }
      total_size += 1 * this->service_list_size() + data_size;
    }
    
    if (!unknown_fields().empty()) {
      total_size +=
        ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
          unknown_fields());
    }
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = total_size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
    return total_size;
  }
  
  void CMsgSOCacheSubscribedUpToDate::MergeFrom(const ::google::protobuf::Message& from) {
    GOOGLE_CHECK_NE(&from, this);
    const CMsgSOCacheSubscribedUpToDate* source =
      ::google::protobuf::internal::dynamic_cast_if_available<const CMsgSOCacheSubscribedUpToDate*>(
        &from);
    if (source == NULL) {
      ::google::protobuf::internal::ReflectionOps::Merge(from, this);
    } else {
      MergeFrom(*source);
    }
  }
  
  void CMsgSOCacheSubscribedUpToDate::MergeFrom(const CMsgSOCacheSubscribedUpToDate& from) {
    GOOGLE_CHECK_NE(&from, this);
    service_list_.MergeFrom(from.service_list_);
    if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      if (from._has_bit(0)) {
        set_version(from.version());
      }
      if (from._has_bit(1)) {
        mutable_owner_soid()->::CMsgSOIDOwner::MergeFrom(from.owner_soid());
      }
      if (from._has_bit(2)) {
        set_service_id(from.service_id());
      }
      if (from._has_bit(4)) {
        set_sync_version(from.sync_version());
      }
    }
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
  
  void CMsgSOCacheSubscribedUpToDate::CopyFrom(const ::google::protobuf::Message& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void CMsgSOCacheSubscribedUpToDate::CopyFrom(const CMsgSOCacheSubscribedUpToDate& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  bool CMsgSOCacheSubscribedUpToDate::IsInitialized() const {
    
    return true;
  }
  
  void CMsgSOCacheSubscribedUpToDate::Swap(CMsgSOCacheSubscribedUpToDate* other) {
    if (other != this) {
      std::swap(version_, other->version_);
      std::swap(owner_soid_, other->owner_soid_);
      std::swap(service_id_, other->service_id_);
      service_list_.Swap(&other->service_list_);
      std::swap(sync_version_, other->sync_version_);
      std::swap(_has_bits_[0], other->_has_bits_[0]);
      _unknown_fields_.Swap(&other->_unknown_fields_);
      std::swap(_cached_size_, other->_cached_size_);
    }
  }
  
  ::google::protobuf::Metadata CMsgSOCacheSubscribedUpToDate::GetMetadata() const {
    protobuf_AssignDescriptorsOnce();
    ::google::protobuf::Metadata metadata;
    metadata.descriptor = CMsgSOCacheSubscribedUpToDate_descriptor_;
    metadata.reflection = CMsgSOCacheSubscribedUpToDate_reflection_;
    return metadata;
  }
  
  
  // ===================================================================
  
  #ifndef _MSC_VER
  const int CMsgSOCacheUnsubscribed::kOwnerFieldNumber;
  #endif  // !_MSC_VER
  
  CMsgSOCacheUnsubscribed::CMsgSOCacheUnsubscribed()
    : ::google::protobuf::Message() {
    SharedCtor();
  }
  
  void CMsgSOCacheUnsubscribed::InitAsDefaultInstance() {
  }
  
  CMsgSOCacheUnsubscribed::CMsgSOCacheUnsubscribed(const CMsgSOCacheUnsubscribed& from)
    : ::google::protobuf::Message() {
    SharedCtor();
    MergeFrom(from);
  }
  
  void CMsgSOCacheUnsubscribed::SharedCtor() {
    _cached_size_ = 0;
    owner_ = GOOGLE_ULONGLONG(0);
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
  }
  
  CMsgSOCacheUnsubscribed::~CMsgSOCacheUnsubscribed() {
    SharedDtor();
  }
  
  void CMsgSOCacheUnsubscribed::SharedDtor() {
    if (this != default_instance_) {
    }
  }
  
  void CMsgSOCacheUnsubscribed::SetCachedSize(int size) const {
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
  }
  const ::google::protobuf::Descriptor* CMsgSOCacheUnsubscribed::descriptor() {
    protobuf_AssignDescriptorsOnce();
    return CMsgSOCacheUnsubscribed_descriptor_;
  }
  
  const CMsgSOCacheUnsubscribed& CMsgSOCacheUnsubscribed::default_instance() {
    if (default_instance_ == NULL) protobuf_AddDesc_gcsdk_5fgcmessages_2eproto();  return *default_instance_;
  }
  
  CMsgSOCacheUnsubscribed* CMsgSOCacheUnsubscribed::default_instance_ = NULL;
  
  CMsgSOCacheUnsubscribed* CMsgSOCacheUnsubscribed::New() const {
    return new CMsgSOCacheUnsubscribed;
  }
  
  void CMsgSOCacheUnsubscribed::Clear() {
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      owner_ = GOOGLE_ULONGLONG(0);
    }
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
    mutable_unknown_fields()->Clear();
  }
  
  bool CMsgSOCacheUnsubscribed::MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) {
  #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
    ::google::protobuf::uint32 tag;
    while ((tag = input->ReadTag()) != 0) {
      switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
        // optional fixed64 owner = 1;
        case 1: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                   input, &owner_)));
            _set_bit(0);
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectAtEnd()) return true;
          break;
        }
        
        default: {
        handle_uninterpreted:
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
            return true;
          }
          DO_(::google::protobuf::internal::WireFormat::SkipField(
                input, tag, mutable_unknown_fields()));
          break;
        }
      }
    }
    return true;
  #undef DO_
  }
  
  void CMsgSOCacheUnsubscribed::SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const {
    // optional fixed64 owner = 1;
    if (_has_bit(0)) {
      ::google::protobuf::internal::WireFormatLite::WriteFixed64(1, this->owner(), output);
    }
    
    if (!unknown_fields().empty()) {
      ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
          unknown_fields(), output);
    }
  }
  
  ::google::protobuf::uint8* CMsgSOCacheUnsubscribed::SerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const {
    // optional fixed64 owner = 1;
    if (_has_bit(0)) {
      target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(1, this->owner(), target);
    }
    
    if (!unknown_fields().empty()) {
      target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
          unknown_fields(), target);
    }
    return target;
  }
  
  int CMsgSOCacheUnsubscribed::ByteSize() const {
    int total_size = 0;
    
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      // optional fixed64 owner = 1;
      if (has_owner()) {
        total_size += 1 + 8;
      }
      
    }
    if (!unknown_fields().empty()) {
      total_size +=
        ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
          unknown_fields());
    }
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = total_size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
    return total_size;
  }
  
  void CMsgSOCacheUnsubscribed::MergeFrom(const ::google::protobuf::Message& from) {
    GOOGLE_CHECK_NE(&from, this);
    const CMsgSOCacheUnsubscribed* source =
      ::google::protobuf::internal::dynamic_cast_if_available<const CMsgSOCacheUnsubscribed*>(
        &from);
    if (source == NULL) {
      ::google::protobuf::internal::ReflectionOps::Merge(from, this);
    } else {
      MergeFrom(*source);
    }
  }
  
  void CMsgSOCacheUnsubscribed::MergeFrom(const CMsgSOCacheUnsubscribed& from) {
    GOOGLE_CHECK_NE(&from, this);
    if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      if (from._has_bit(0)) {
        set_owner(from.owner());
      }
    }
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
  
  void CMsgSOCacheUnsubscribed::CopyFrom(const ::google::protobuf::Message& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void CMsgSOCacheUnsubscribed::CopyFrom(const CMsgSOCacheUnsubscribed& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  bool CMsgSOCacheUnsubscribed::IsInitialized() const {
    
    return true;
  }
  
  void CMsgSOCacheUnsubscribed::Swap(CMsgSOCacheUnsubscribed* other) {
    if (other != this) {
      std::swap(owner_, other->owner_);
      std::swap(_has_bits_[0], other->_has_bits_[0]);
      _unknown_fields_.Swap(&other->_unknown_fields_);
      std::swap(_cached_size_, other->_cached_size_);
    }
  }
  
  ::google::protobuf::Metadata CMsgSOCacheUnsubscribed::GetMetadata() const {
    protobuf_AssignDescriptorsOnce();
    ::google::protobuf::Metadata metadata;
    metadata.descriptor = CMsgSOCacheUnsubscribed_descriptor_;
    metadata.reflection = CMsgSOCacheUnsubscribed_reflection_;
    return metadata;
  }
  
  
  // ===================================================================
  
  #ifndef _MSC_VER
  const int CMsgSOCacheSubscriptionCheck::kOwnerFieldNumber;
  const int CMsgSOCacheSubscriptionCheck::kVersionFieldNumber;
  const int CMsgSOCacheSubscriptionCheck::kOwnerSoidFieldNumber;
  const int CMsgSOCacheSubscriptionCheck::kServiceIdFieldNumber;
  const int CMsgSOCacheSubscriptionCheck::kServiceListFieldNumber;
  const int CMsgSOCacheSubscriptionCheck::kSyncVersionFieldNumber;
  #endif  // !_MSC_VER
  
  CMsgSOCacheSubscriptionCheck::CMsgSOCacheSubscriptionCheck()
    : ::google::protobuf::Message() {
    SharedCtor();
  }
  
  void CMsgSOCacheSubscriptionCheck::InitAsDefaultInstance() {
    owner_soid_ = const_cast< ::CMsgSOIDOwner*>(&::CMsgSOIDOwner::default_instance());
  }
  
  CMsgSOCacheSubscriptionCheck::CMsgSOCacheSubscriptionCheck(const CMsgSOCacheSubscriptionCheck& from)
    : ::google::protobuf::Message() {
    SharedCtor();
    MergeFrom(from);
  }
  
  void CMsgSOCacheSubscriptionCheck::SharedCtor() {
    _cached_size_ = 0;
    owner_ = GOOGLE_ULONGLONG(0);
    version_ = GOOGLE_ULONGLONG(0);
    owner_soid_ = NULL;
    service_id_ = 0u;
    sync_version_ = GOOGLE_ULONGLONG(0);
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
  }
  
  CMsgSOCacheSubscriptionCheck::~CMsgSOCacheSubscriptionCheck() {
    SharedDtor();
  }
  
  void CMsgSOCacheSubscriptionCheck::SharedDtor() {
    if (this != default_instance_) {
      delete owner_soid_;
    }
  }
  
  void CMsgSOCacheSubscriptionCheck::SetCachedSize(int size) const {
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
  }
  const ::google::protobuf::Descriptor* CMsgSOCacheSubscriptionCheck::descriptor() {
    protobuf_AssignDescriptorsOnce();
    return CMsgSOCacheSubscriptionCheck_descriptor_;
  }
  
  const CMsgSOCacheSubscriptionCheck& CMsgSOCacheSubscriptionCheck::default_instance() {
    if (default_instance_ == NULL) protobuf_AddDesc_gcsdk_5fgcmessages_2eproto();  return *default_instance_;
  }
  
  CMsgSOCacheSubscriptionCheck* CMsgSOCacheSubscriptionCheck::default_instance_ = NULL;
  
  CMsgSOCacheSubscriptionCheck* CMsgSOCacheSubscriptionCheck::New() const {
    return new CMsgSOCacheSubscriptionCheck;
  }
  
  void CMsgSOCacheSubscriptionCheck::Clear() {
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      owner_ = GOOGLE_ULONGLONG(0);
      version_ = GOOGLE_ULONGLONG(0);
      if (_has_bit(2)) {
        if (owner_soid_ != NULL) owner_soid_->::CMsgSOIDOwner::Clear();
      }
      service_id_ = 0u;
      sync_version_ = GOOGLE_ULONGLONG(0);
    }
    service_list_.Clear();
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
    mutable_unknown_fields()->Clear();
  }
  
  bool CMsgSOCacheSubscriptionCheck::MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) {
  #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
    ::google::protobuf::uint32 tag;
    while ((tag = input->ReadTag()) != 0) {
      switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
        // optional fixed64 owner = 1;
        case 1: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                   input, &owner_)));
            _set_bit(0);
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectTag(17)) goto parse_version;
          break;
        }
        
        // optional fixed64 version = 2;
        case 2: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
           parse_version:
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                   input, &version_)));
            _set_bit(1);
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectTag(26)) goto parse_owner_soid;
          break;
        }
        
        // optional .CMsgSOIDOwner owner_soid = 3;
        case 3: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
           parse_owner_soid:
            DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                 input, mutable_owner_soid()));
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectTag(32)) goto parse_service_id;
          break;
        }
        
        // optional uint32 service_id = 4;
        case 4: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
           parse_service_id:
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                   input, &service_id_)));
            _set_bit(3);
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectTag(40)) goto parse_service_list;
          break;
        }
        
        // repeated uint32 service_list = 5;
        case 5: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
           parse_service_list:
            DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                     ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                   1, 40, input, this->mutable_service_list())));
          } else if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag)
                     == ::google::protobuf::internal::WireFormatLite::
                        WIRETYPE_LENGTH_DELIMITED) {
            DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                     ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                   input, this->mutable_service_list())));
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectTag(40)) goto parse_service_list;
          if (input->ExpectTag(49)) goto parse_sync_version;
          break;
        }
        
        // optional fixed64 sync_version = 6;
        case 6: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
           parse_sync_version:
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                   input, &sync_version_)));
            _set_bit(5);
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectAtEnd()) return true;
          break;
        }
        
        default: {
        handle_uninterpreted:
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
            return true;
          }
          DO_(::google::protobuf::internal::WireFormat::SkipField(
                input, tag, mutable_unknown_fields()));
          break;
        }
      }
    }
    return true;
  #undef DO_
  }
  
  void CMsgSOCacheSubscriptionCheck::SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const {
    // optional fixed64 owner = 1;
    if (_has_bit(0)) {
      ::google::protobuf::internal::WireFormatLite::WriteFixed64(1, this->owner(), output);
    }
    
    // optional fixed64 version = 2;
    if (_has_bit(1)) {
      ::google::protobuf::internal::WireFormatLite::WriteFixed64(2, this->version(), output);
    }
    
    // optional .CMsgSOIDOwner owner_soid = 3;
    if (_has_bit(2)) {
      ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
        3, this->owner_soid(), output);
    }
    
    // optional uint32 service_id = 4;
    if (_has_bit(3)) {
      ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->service_id(), output);
    }
    
    // repeated uint32 service_list = 5;
    for (int i = 0; i < this->service_list_size(); i++) {
      ::google::protobuf::internal::WireFormatLite::WriteUInt32(
        5, this->service_list(i), output);
    }
    
    // optional fixed64 sync_version = 6;
    if (_has_bit(5)) {
      ::google::protobuf::internal::WireFormatLite::WriteFixed64(6, this->sync_version(), output);
    }
    
    if (!unknown_fields().empty()) {
      ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
          unknown_fields(), output);
    }
  }
  
  ::google::protobuf::uint8* CMsgSOCacheSubscriptionCheck::SerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const {
    // optional fixed64 owner = 1;
    if (_has_bit(0)) {
      target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(1, this->owner(), target);
    }
    
    // optional fixed64 version = 2;
    if (_has_bit(1)) {
      target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(2, this->version(), target);
    }
    
    // optional .CMsgSOIDOwner owner_soid = 3;
    if (_has_bit(2)) {
      target = ::google::protobuf::internal::WireFormatLite::
        WriteMessageNoVirtualToArray(
          3, this->owner_soid(), target);
    }
    
    // optional uint32 service_id = 4;
    if (_has_bit(3)) {
      target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(4, this->service_id(), target);
    }
    
    // repeated uint32 service_list = 5;
    for (int i = 0; i < this->service_list_size(); i++) {
      target = ::google::protobuf::internal::WireFormatLite::
        WriteUInt32ToArray(5, this->service_list(i), target);
    }
    
    // optional fixed64 sync_version = 6;
    if (_has_bit(5)) {
      target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(6, this->sync_version(), target);
    }
    
    if (!unknown_fields().empty()) {
      target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
          unknown_fields(), target);
    }
    return target;
  }
  
  int CMsgSOCacheSubscriptionCheck::ByteSize() const {
    int total_size = 0;
    
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      // optional fixed64 owner = 1;
      if (has_owner()) {
        total_size += 1 + 8;
      }
      
      // optional fixed64 version = 2;
      if (has_version()) {
        total_size += 1 + 8;
      }
      
      // optional .CMsgSOIDOwner owner_soid = 3;
      if (has_owner_soid()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
            this->owner_soid());
      }
      
      // optional uint32 service_id = 4;
      if (has_service_id()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormatLite::UInt32Size(
            this->service_id());
      }
      
      // optional fixed64 sync_version = 6;
      if (has_sync_version()) {
        total_size += 1 + 8;
      }
      
    }
    // repeated uint32 service_list = 5;
    {
      int data_size = 0;
      for (int i = 0; i < this->service_list_size(); i++) {
        data_size += ::google::protobuf::internal::WireFormatLite::
          UInt32Size(this->service_list(i));
      }
      total_size += 1 * this->service_list_size() + data_size;
    }
    
    if (!unknown_fields().empty()) {
      total_size +=
        ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
          unknown_fields());
    }
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = total_size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
    return total_size;
  }
  
  void CMsgSOCacheSubscriptionCheck::MergeFrom(const ::google::protobuf::Message& from) {
    GOOGLE_CHECK_NE(&from, this);
    const CMsgSOCacheSubscriptionCheck* source =
      ::google::protobuf::internal::dynamic_cast_if_available<const CMsgSOCacheSubscriptionCheck*>(
        &from);
    if (source == NULL) {
      ::google::protobuf::internal::ReflectionOps::Merge(from, this);
    } else {
      MergeFrom(*source);
    }
  }
  
  void CMsgSOCacheSubscriptionCheck::MergeFrom(const CMsgSOCacheSubscriptionCheck& from) {
    GOOGLE_CHECK_NE(&from, this);
    service_list_.MergeFrom(from.service_list_);
    if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      if (from._has_bit(0)) {
        set_owner(from.owner());
      }
      if (from._has_bit(1)) {
        set_version(from.version());
      }
      if (from._has_bit(2)) {
        mutable_owner_soid()->::CMsgSOIDOwner::MergeFrom(from.owner_soid());
      }
      if (from._has_bit(3)) {
        set_service_id(from.service_id());
      }
      if (from._has_bit(5)) {
        set_sync_version(from.sync_version());
      }
    }
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
  
  void CMsgSOCacheSubscriptionCheck::CopyFrom(const ::google::protobuf::Message& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void CMsgSOCacheSubscriptionCheck::CopyFrom(const CMsgSOCacheSubscriptionCheck& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  bool CMsgSOCacheSubscriptionCheck::IsInitialized() const {
    
    return true;
  }
  
  void CMsgSOCacheSubscriptionCheck::Swap(CMsgSOCacheSubscriptionCheck* other) {
    if (other != this) {
      std::swap(owner_, other->owner_);
      std::swap(version_, other->version_);
      std::swap(owner_soid_, other->owner_soid_);
      std::swap(service_id_, other->service_id_);
      service_list_.Swap(&other->service_list_);
      std::swap(sync_version_, other->sync_version_);
      std::swap(_has_bits_[0], other->_has_bits_[0]);
      _unknown_fields_.Swap(&other->_unknown_fields_);
      std::swap(_cached_size_, other->_cached_size_);
    }
  }
  
  ::google::protobuf::Metadata CMsgSOCacheSubscriptionCheck::GetMetadata() const {
    protobuf_AssignDescriptorsOnce();
    ::google::protobuf::Metadata metadata;
    metadata.descriptor = CMsgSOCacheSubscriptionCheck_descriptor_;
    metadata.reflection = CMsgSOCacheSubscriptionCheck_reflection_;
    return metadata;
  }
  
  
  // ===================================================================
  
  #ifndef _MSC_VER
  const int CMsgSOCacheSubscriptionRefresh::kOwnerFieldNumber;
  const int CMsgSOCacheSubscriptionRefresh::kOwnerSoidFieldNumber;
  #endif  // !_MSC_VER
  
  CMsgSOCacheSubscriptionRefresh::CMsgSOCacheSubscriptionRefresh()
    : ::google::protobuf::Message() {
    SharedCtor();
  }
  
  void CMsgSOCacheSubscriptionRefresh::InitAsDefaultInstance() {
    owner_soid_ = const_cast< ::CMsgSOIDOwner*>(&::CMsgSOIDOwner::default_instance());
  }
  
  CMsgSOCacheSubscriptionRefresh::CMsgSOCacheSubscriptionRefresh(const CMsgSOCacheSubscriptionRefresh& from)
    : ::google::protobuf::Message() {
    SharedCtor();
    MergeFrom(from);
  }
  
  void CMsgSOCacheSubscriptionRefresh::SharedCtor() {
    _cached_size_ = 0;
    owner_ = GOOGLE_ULONGLONG(0);
    owner_soid_ = NULL;
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
  }
  
  CMsgSOCacheSubscriptionRefresh::~CMsgSOCacheSubscriptionRefresh() {
    SharedDtor();
  }
  
  void CMsgSOCacheSubscriptionRefresh::SharedDtor() {
    if (this != default_instance_) {
      delete owner_soid_;
    }
  }
  
  void CMsgSOCacheSubscriptionRefresh::SetCachedSize(int size) const {
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
  }
  const ::google::protobuf::Descriptor* CMsgSOCacheSubscriptionRefresh::descriptor() {
    protobuf_AssignDescriptorsOnce();
    return CMsgSOCacheSubscriptionRefresh_descriptor_;
  }
  
  const CMsgSOCacheSubscriptionRefresh& CMsgSOCacheSubscriptionRefresh::default_instance() {
    if (default_instance_ == NULL) protobuf_AddDesc_gcsdk_5fgcmessages_2eproto();  return *default_instance_;
  }
  
  CMsgSOCacheSubscriptionRefresh* CMsgSOCacheSubscriptionRefresh::default_instance_ = NULL;
  
  CMsgSOCacheSubscriptionRefresh* CMsgSOCacheSubscriptionRefresh::New() const {
    return new CMsgSOCacheSubscriptionRefresh;
  }
  
  void CMsgSOCacheSubscriptionRefresh::Clear() {
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      owner_ = GOOGLE_ULONGLONG(0);
      if (_has_bit(1)) {
        if (owner_soid_ != NULL) owner_soid_->::CMsgSOIDOwner::Clear();
      }
    }
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
    mutable_unknown_fields()->Clear();
  }
  
  bool CMsgSOCacheSubscriptionRefresh::MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) {
  #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
    ::google::protobuf::uint32 tag;
    while ((tag = input->ReadTag()) != 0) {
      switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
        // optional fixed64 owner = 1;
        case 1: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                   input, &owner_)));
            _set_bit(0);
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectTag(18)) goto parse_owner_soid;
          break;
        }
        
        // optional .CMsgSOIDOwner owner_soid = 2;
        case 2: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
           parse_owner_soid:
            DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                 input, mutable_owner_soid()));
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectAtEnd()) return true;
          break;
        }
        
        default: {
        handle_uninterpreted:
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
            return true;
          }
          DO_(::google::protobuf::internal::WireFormat::SkipField(
                input, tag, mutable_unknown_fields()));
          break;
        }
      }
    }
    return true;
  #undef DO_
  }
  
  void CMsgSOCacheSubscriptionRefresh::SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const {
    // optional fixed64 owner = 1;
    if (_has_bit(0)) {
      ::google::protobuf::internal::WireFormatLite::WriteFixed64(1, this->owner(), output);
    }
    
    // optional .CMsgSOIDOwner owner_soid = 2;
    if (_has_bit(1)) {
      ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
        2, this->owner_soid(), output);
    }
    
    if (!unknown_fields().empty()) {
      ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
          unknown_fields(), output);
    }
  }
  
  ::google::protobuf::uint8* CMsgSOCacheSubscriptionRefresh::SerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const {
    // optional fixed64 owner = 1;
    if (_has_bit(0)) {
      target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(1, this->owner(), target);
    }
    
    // optional .CMsgSOIDOwner owner_soid = 2;
    if (_has_bit(1)) {
      target = ::google::protobuf::internal::WireFormatLite::
        WriteMessageNoVirtualToArray(
          2, this->owner_soid(), target);
    }
    
    if (!unknown_fields().empty()) {
      target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
          unknown_fields(), target);
    }
    return target;
  }
  
  int CMsgSOCacheSubscriptionRefresh::ByteSize() const {
    int total_size = 0;
    
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      // optional fixed64 owner = 1;
      if (has_owner()) {
        total_size += 1 + 8;
      }
      
      // optional .CMsgSOIDOwner owner_soid = 2;
      if (has_owner_soid()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
            this->owner_soid());
      }
      
    }
    if (!unknown_fields().empty()) {
      total_size +=
        ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
          unknown_fields());
    }
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = total_size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
    return total_size;
  }
  
  void CMsgSOCacheSubscriptionRefresh::MergeFrom(const ::google::protobuf::Message& from) {
    GOOGLE_CHECK_NE(&from, this);
    const CMsgSOCacheSubscriptionRefresh* source =
      ::google::protobuf::internal::dynamic_cast_if_available<const CMsgSOCacheSubscriptionRefresh*>(
        &from);
    if (source == NULL) {
      ::google::protobuf::internal::ReflectionOps::Merge(from, this);
    } else {
      MergeFrom(*source);
    }
  }
  
  void CMsgSOCacheSubscriptionRefresh::MergeFrom(const CMsgSOCacheSubscriptionRefresh& from) {
    GOOGLE_CHECK_NE(&from, this);
    if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      if (from._has_bit(0)) {
        set_owner(from.owner());
      }
      if (from._has_bit(1)) {
        mutable_owner_soid()->::CMsgSOIDOwner::MergeFrom(from.owner_soid());
      }
    }
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
  
  void CMsgSOCacheSubscriptionRefresh::CopyFrom(const ::google::protobuf::Message& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void CMsgSOCacheSubscriptionRefresh::CopyFrom(const CMsgSOCacheSubscriptionRefresh& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  bool CMsgSOCacheSubscriptionRefresh::IsInitialized() const {
    
    return true;
  }
  
  void CMsgSOCacheSubscriptionRefresh::Swap(CMsgSOCacheSubscriptionRefresh* other) {
    if (other != this) {
      std::swap(owner_, other->owner_);
      std::swap(owner_soid_, other->owner_soid_);
      std::swap(_has_bits_[0], other->_has_bits_[0]);
      _unknown_fields_.Swap(&other->_unknown_fields_);
      std::swap(_cached_size_, other->_cached_size_);
    }
  }
  
  ::google::protobuf::Metadata CMsgSOCacheSubscriptionRefresh::GetMetadata() const {
    protobuf_AssignDescriptorsOnce();
    ::google::protobuf::Metadata metadata;
    metadata.descriptor = CMsgSOCacheSubscriptionRefresh_descriptor_;
    metadata.reflection = CMsgSOCacheSubscriptionRefresh_reflection_;
    return metadata;
  }
  
  
  // ===================================================================
  
  #ifndef _MSC_VER
  const int CMsgSOCacheVersion::kVersionFieldNumber;
  #endif  // !_MSC_VER
  
  CMsgSOCacheVersion::CMsgSOCacheVersion()
    : ::google::protobuf::Message() {
    SharedCtor();
  }
  
  void CMsgSOCacheVersion::InitAsDefaultInstance() {
  }
  
  CMsgSOCacheVersion::CMsgSOCacheVersion(const CMsgSOCacheVersion& from)
    : ::google::protobuf::Message() {
    SharedCtor();
    MergeFrom(from);
  }
  
  void CMsgSOCacheVersion::SharedCtor() {
    _cached_size_ = 0;
    version_ = GOOGLE_ULONGLONG(0);
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
  }
  
  CMsgSOCacheVersion::~CMsgSOCacheVersion() {
    SharedDtor();
  }
  
  void CMsgSOCacheVersion::SharedDtor() {
    if (this != default_instance_) {
    }
  }
  
  void CMsgSOCacheVersion::SetCachedSize(int size) const {
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
  }
  const ::google::protobuf::Descriptor* CMsgSOCacheVersion::descriptor() {
    protobuf_AssignDescriptorsOnce();
    return CMsgSOCacheVersion_descriptor_;
  }
  
  const CMsgSOCacheVersion& CMsgSOCacheVersion::default_instance() {
    if (default_instance_ == NULL) protobuf_AddDesc_gcsdk_5fgcmessages_2eproto();  return *default_instance_;
  }
  
  CMsgSOCacheVersion* CMsgSOCacheVersion::default_instance_ = NULL;
  
  CMsgSOCacheVersion* CMsgSOCacheVersion::New() const {
    return new CMsgSOCacheVersion;
  }
  
  void CMsgSOCacheVersion::Clear() {
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      version_ = GOOGLE_ULONGLONG(0);
    }
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
    mutable_unknown_fields()->Clear();
  }
  
  bool CMsgSOCacheVersion::MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) {
  #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
    ::google::protobuf::uint32 tag;
    while ((tag = input->ReadTag()) != 0) {
      switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
        // optional fixed64 version = 1;
        case 1: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                   input, &version_)));
            _set_bit(0);
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectAtEnd()) return true;
          break;
        }
        
        default: {
        handle_uninterpreted:
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
            return true;
          }
          DO_(::google::protobuf::internal::WireFormat::SkipField(
                input, tag, mutable_unknown_fields()));
          break;
        }
      }
    }
    return true;
  #undef DO_
  }
  
  void CMsgSOCacheVersion::SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const {
    // optional fixed64 version = 1;
    if (_has_bit(0)) {
      ::google::protobuf::internal::WireFormatLite::WriteFixed64(1, this->version(), output);
    }
    
    if (!unknown_fields().empty()) {
      ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
          unknown_fields(), output);
    }
  }
  
  ::google::protobuf::uint8* CMsgSOCacheVersion::SerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const {
    // optional fixed64 version = 1;
    if (_has_bit(0)) {
      target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(1, this->version(), target);
    }
    
    if (!unknown_fields().empty()) {
      target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
          unknown_fields(), target);
    }
    return target;
  }
  
  int CMsgSOCacheVersion::ByteSize() const {
    int total_size = 0;
    
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      // optional fixed64 version = 1;
      if (has_version()) {
        total_size += 1 + 8;
      }
      
    }
    if (!unknown_fields().empty()) {
      total_size +=
        ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
          unknown_fields());
    }
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = total_size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
    return total_size;
  }
  
  void CMsgSOCacheVersion::MergeFrom(const ::google::protobuf::Message& from) {
    GOOGLE_CHECK_NE(&from, this);
    const CMsgSOCacheVersion* source =
      ::google::protobuf::internal::dynamic_cast_if_available<const CMsgSOCacheVersion*>(
        &from);
    if (source == NULL) {
      ::google::protobuf::internal::ReflectionOps::Merge(from, this);
    } else {
      MergeFrom(*source);
    }
  }
  
  void CMsgSOCacheVersion::MergeFrom(const CMsgSOCacheVersion& from) {
    GOOGLE_CHECK_NE(&from, this);
    if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      if (from._has_bit(0)) {
        set_version(from.version());
      }
    }
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
  
  void CMsgSOCacheVersion::CopyFrom(const ::google::protobuf::Message& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void CMsgSOCacheVersion::CopyFrom(const CMsgSOCacheVersion& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  bool CMsgSOCacheVersion::IsInitialized() const {
    
    return true;
  }
  
  void CMsgSOCacheVersion::Swap(CMsgSOCacheVersion* other) {
    if (other != this) {
      std::swap(version_, other->version_);
      std::swap(_has_bits_[0], other->_has_bits_[0]);
      _unknown_fields_.Swap(&other->_unknown_fields_);
      std::swap(_cached_size_, other->_cached_size_);
    }
  }
  
  ::google::protobuf::Metadata CMsgSOCacheVersion::GetMetadata() const {
    protobuf_AssignDescriptorsOnce();
    ::google::protobuf::Metadata metadata;
    metadata.descriptor = CMsgSOCacheVersion_descriptor_;
    metadata.reflection = CMsgSOCacheVersion_reflection_;
    return metadata;
  }
  
  
  // ===================================================================
  
  const ::std::string CMsgGCMultiplexMessage::_default_payload_;
  #ifndef _MSC_VER
  const int CMsgGCMultiplexMessage::kMsgtypeFieldNumber;
  const int CMsgGCMultiplexMessage::kPayloadFieldNumber;
  const int CMsgGCMultiplexMessage::kSteamidsFieldNumber;
  #endif  // !_MSC_VER
  
  CMsgGCMultiplexMessage::CMsgGCMultiplexMessage()
    : ::google::protobuf::Message() {
    SharedCtor();
  }
  
  void CMsgGCMultiplexMessage::InitAsDefaultInstance() {
  }
  
  CMsgGCMultiplexMessage::CMsgGCMultiplexMessage(const CMsgGCMultiplexMessage& from)
    : ::google::protobuf::Message() {
    SharedCtor();
    MergeFrom(from);
  }
  
  void CMsgGCMultiplexMessage::SharedCtor() {
    _cached_size_ = 0;
    msgtype_ = 0u;
    payload_ = const_cast< ::std::string*>(&_default_payload_);
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
  }
  
  CMsgGCMultiplexMessage::~CMsgGCMultiplexMessage() {
    SharedDtor();
  }
  
  void CMsgGCMultiplexMessage::SharedDtor() {
    if (payload_ != &_default_payload_) {
      delete payload_;
    }
    if (this != default_instance_) {
    }
  }
  
  void CMsgGCMultiplexMessage::SetCachedSize(int size) const {
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
  }
  const ::google::protobuf::Descriptor* CMsgGCMultiplexMessage::descriptor() {
    protobuf_AssignDescriptorsOnce();
    return CMsgGCMultiplexMessage_descriptor_;
  }
  
  const CMsgGCMultiplexMessage& CMsgGCMultiplexMessage::default_instance() {
    if (default_instance_ == NULL) protobuf_AddDesc_gcsdk_5fgcmessages_2eproto();  return *default_instance_;
  }
  
  CMsgGCMultiplexMessage* CMsgGCMultiplexMessage::default_instance_ = NULL;
  
  CMsgGCMultiplexMessage* CMsgGCMultiplexMessage::New() const {
    return new CMsgGCMultiplexMessage;
  }
  
  void CMsgGCMultiplexMessage::Clear() {
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      msgtype_ = 0u;
      if (_has_bit(1)) {
        if (payload_ != &_default_payload_) {
          payload_->clear();
        }
      }
    }
    steamids_.Clear();
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
    mutable_unknown_fields()->Clear();
  }
  
  bool CMsgGCMultiplexMessage::MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) {
  #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
    ::google::protobuf::uint32 tag;
    while ((tag = input->ReadTag()) != 0) {
      switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
        // optional uint32 msgtype = 1;
        case 1: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                   input, &msgtype_)));
            _set_bit(0);
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectTag(18)) goto parse_payload;
          break;
        }
        
        // optional bytes payload = 2;
        case 2: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
           parse_payload:
            DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                  input, this->mutable_payload()));
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectTag(25)) goto parse_steamids;
          break;
        }
        
        // repeated fixed64 steamids = 3;
        case 3: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
           parse_steamids:
            DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                     ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                   1, 25, input, this->mutable_steamids())));
          } else if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag)
                     == ::google::protobuf::internal::WireFormatLite::
                        WIRETYPE_LENGTH_DELIMITED) {
            DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                     ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                   input, this->mutable_steamids())));
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectTag(25)) goto parse_steamids;
          if (input->ExpectAtEnd()) return true;
          break;
        }
        
        default: {
        handle_uninterpreted:
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
            return true;
          }
          DO_(::google::protobuf::internal::WireFormat::SkipField(
                input, tag, mutable_unknown_fields()));
          break;
        }
      }
    }
    return true;
  #undef DO_
  }
  
  void CMsgGCMultiplexMessage::SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const {
    // optional uint32 msgtype = 1;
    if (_has_bit(0)) {
      ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->msgtype(), output);
    }
    
    // optional bytes payload = 2;
    if (_has_bit(1)) {
      ::google::protobuf::internal::WireFormatLite::WriteBytes(
        2, this->payload(), output);
    }
    
    // repeated fixed64 steamids = 3;
    for (int i = 0; i < this->steamids_size(); i++) {
      ::google::protobuf::internal::WireFormatLite::WriteFixed64(
        3, this->steamids(i), output);
    }
    
    if (!unknown_fields().empty()) {
      ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
          unknown_fields(), output);
    }
  }
  
  ::google::protobuf::uint8* CMsgGCMultiplexMessage::SerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const {
    // optional uint32 msgtype = 1;
    if (_has_bit(0)) {
      target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->msgtype(), target);
    }
    
    // optional bytes payload = 2;
    if (_has_bit(1)) {
      target =
        ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
          2, this->payload(), target);
    }
    
    // repeated fixed64 steamids = 3;
    for (int i = 0; i < this->steamids_size(); i++) {
      target = ::google::protobuf::internal::WireFormatLite::
        WriteFixed64ToArray(3, this->steamids(i), target);
    }
    
    if (!unknown_fields().empty()) {
      target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
          unknown_fields(), target);
    }
    return target;
  }
  
  int CMsgGCMultiplexMessage::ByteSize() const {
    int total_size = 0;
    
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      // optional uint32 msgtype = 1;
      if (has_msgtype()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormatLite::UInt32Size(
            this->msgtype());
      }
      
      // optional bytes payload = 2;
      if (has_payload()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormatLite::BytesSize(
            this->payload());
      }
      
    }
    // repeated fixed64 steamids = 3;
    {
      int data_size = 0;
      data_size = 8 * this->steamids_size();
      total_size += 1 * this->steamids_size() + data_size;
    }
    
    if (!unknown_fields().empty()) {
      total_size +=
        ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
          unknown_fields());
    }
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = total_size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
    return total_size;
  }
  
  void CMsgGCMultiplexMessage::MergeFrom(const ::google::protobuf::Message& from) {
    GOOGLE_CHECK_NE(&from, this);
    const CMsgGCMultiplexMessage* source =
      ::google::protobuf::internal::dynamic_cast_if_available<const CMsgGCMultiplexMessage*>(
        &from);
    if (source == NULL) {
      ::google::protobuf::internal::ReflectionOps::Merge(from, this);
    } else {
      MergeFrom(*source);
    }
  }
  
  void CMsgGCMultiplexMessage::MergeFrom(const CMsgGCMultiplexMessage& from) {
    GOOGLE_CHECK_NE(&from, this);
    steamids_.MergeFrom(from.steamids_);
    if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      if (from._has_bit(0)) {
        set_msgtype(from.msgtype());
      }
      if (from._has_bit(1)) {
        set_payload(from.payload());
      }
    }
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
  
  void CMsgGCMultiplexMessage::CopyFrom(const ::google::protobuf::Message& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void CMsgGCMultiplexMessage::CopyFrom(const CMsgGCMultiplexMessage& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  bool CMsgGCMultiplexMessage::IsInitialized() const {
    
    return true;
  }
  
  void CMsgGCMultiplexMessage::Swap(CMsgGCMultiplexMessage* other) {
    if (other != this) {
      std::swap(msgtype_, other->msgtype_);
      std::swap(payload_, other->payload_);
      steamids_.Swap(&other->steamids_);
      std::swap(_has_bits_[0], other->_has_bits_[0]);
      _unknown_fields_.Swap(&other->_unknown_fields_);
      std::swap(_cached_size_, other->_cached_size_);
    }
  }
  
  ::google::protobuf::Metadata CMsgGCMultiplexMessage::GetMetadata() const {
    protobuf_AssignDescriptorsOnce();
    ::google::protobuf::Metadata metadata;
    metadata.descriptor = CMsgGCMultiplexMessage_descriptor_;
    metadata.reflection = CMsgGCMultiplexMessage_reflection_;
    return metadata;
  }
  
  
  // ===================================================================
  
  const ::std::string CGCToGCMsgMasterAck::_default_machine_name_;
  const ::std::string CGCToGCMsgMasterAck::_default_process_name_;
  #ifndef _MSC_VER
  const int CGCToGCMsgMasterAck::kDirIndexFieldNumber;
  const int CGCToGCMsgMasterAck::kMachineNameFieldNumber;
  const int CGCToGCMsgMasterAck::kProcessNameFieldNumber;
  const int CGCToGCMsgMasterAck::kTypeInstancesFieldNumber;
  #endif  // !_MSC_VER
  
  CGCToGCMsgMasterAck::CGCToGCMsgMasterAck()
    : ::google::protobuf::Message() {
    SharedCtor();
  }
  
  void CGCToGCMsgMasterAck::InitAsDefaultInstance() {
  }
  
  CGCToGCMsgMasterAck::CGCToGCMsgMasterAck(const CGCToGCMsgMasterAck& from)
    : ::google::protobuf::Message() {
    SharedCtor();
    MergeFrom(from);
  }
  
  void CGCToGCMsgMasterAck::SharedCtor() {
    _cached_size_ = 0;
    dir_index_ = 0u;
    machine_name_ = const_cast< ::std::string*>(&_default_machine_name_);
    process_name_ = const_cast< ::std::string*>(&_default_process_name_);
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
  }
  
  CGCToGCMsgMasterAck::~CGCToGCMsgMasterAck() {
    SharedDtor();
  }
  
  void CGCToGCMsgMasterAck::SharedDtor() {
    if (machine_name_ != &_default_machine_name_) {
      delete machine_name_;
    }
    if (process_name_ != &_default_process_name_) {
      delete process_name_;
    }
    if (this != default_instance_) {
    }
  }
  
  void CGCToGCMsgMasterAck::SetCachedSize(int size) const {
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
  }
  const ::google::protobuf::Descriptor* CGCToGCMsgMasterAck::descriptor() {
    protobuf_AssignDescriptorsOnce();
    return CGCToGCMsgMasterAck_descriptor_;
  }
  
  const CGCToGCMsgMasterAck& CGCToGCMsgMasterAck::default_instance() {
    if (default_instance_ == NULL) protobuf_AddDesc_gcsdk_5fgcmessages_2eproto();  return *default_instance_;
  }
  
  CGCToGCMsgMasterAck* CGCToGCMsgMasterAck::default_instance_ = NULL;
  
  CGCToGCMsgMasterAck* CGCToGCMsgMasterAck::New() const {
    return new CGCToGCMsgMasterAck;
  }
  
  void CGCToGCMsgMasterAck::Clear() {
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      dir_index_ = 0u;
      if (_has_bit(1)) {
        if (machine_name_ != &_default_machine_name_) {
          machine_name_->clear();
        }
      }
      if (_has_bit(2)) {
        if (process_name_ != &_default_process_name_) {
          process_name_->clear();
        }
      }
    }
    type_instances_.Clear();
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
    mutable_unknown_fields()->Clear();
  }
  
  bool CGCToGCMsgMasterAck::MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) {
  #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
    ::google::protobuf::uint32 tag;
    while ((tag = input->ReadTag()) != 0) {
      switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
        // optional uint32 dir_index = 1;
        case 1: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                   input, &dir_index_)));
            _set_bit(0);
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectTag(26)) goto parse_machine_name;
          break;
        }
        
        // optional string machine_name = 3;
        case 3: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
           parse_machine_name:
            DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                  input, this->mutable_machine_name()));
            ::google::protobuf::internal::WireFormat::VerifyUTF8String(
              this->machine_name().data(), this->machine_name().length(),
              ::google::protobuf::internal::WireFormat::PARSE);
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectTag(34)) goto parse_process_name;
          break;
        }
        
        // optional string process_name = 4;
        case 4: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
           parse_process_name:
            DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                  input, this->mutable_process_name()));
            ::google::protobuf::internal::WireFormat::VerifyUTF8String(
              this->process_name().data(), this->process_name().length(),
              ::google::protobuf::internal::WireFormat::PARSE);
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectTag(40)) goto parse_type_instances;
          break;
        }
        
        // repeated uint32 type_instances = 5;
        case 5: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
           parse_type_instances:
            DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                     ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                   1, 40, input, this->mutable_type_instances())));
          } else if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag)
                     == ::google::protobuf::internal::WireFormatLite::
                        WIRETYPE_LENGTH_DELIMITED) {
            DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                     ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                   input, this->mutable_type_instances())));
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectTag(40)) goto parse_type_instances;
          if (input->ExpectAtEnd()) return true;
          break;
        }
        
        default: {
        handle_uninterpreted:
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
            return true;
          }
          DO_(::google::protobuf::internal::WireFormat::SkipField(
                input, tag, mutable_unknown_fields()));
          break;
        }
      }
    }
    return true;
  #undef DO_
  }
  
  void CGCToGCMsgMasterAck::SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const {
    // optional uint32 dir_index = 1;
    if (_has_bit(0)) {
      ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->dir_index(), output);
    }
    
    // optional string machine_name = 3;
    if (_has_bit(1)) {
      ::google::protobuf::internal::WireFormat::VerifyUTF8String(
        this->machine_name().data(), this->machine_name().length(),
        ::google::protobuf::internal::WireFormat::SERIALIZE);
      ::google::protobuf::internal::WireFormatLite::WriteString(
        3, this->machine_name(), output);
    }
    
    // optional string process_name = 4;
    if (_has_bit(2)) {
      ::google::protobuf::internal::WireFormat::VerifyUTF8String(
        this->process_name().data(), this->process_name().length(),
        ::google::protobuf::internal::WireFormat::SERIALIZE);
      ::google::protobuf::internal::WireFormatLite::WriteString(
        4, this->process_name(), output);
    }
    
    // repeated uint32 type_instances = 5;
    for (int i = 0; i < this->type_instances_size(); i++) {
      ::google::protobuf::internal::WireFormatLite::WriteUInt32(
        5, this->type_instances(i), output);
    }
    
    if (!unknown_fields().empty()) {
      ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
          unknown_fields(), output);
    }
  }
  
  ::google::protobuf::uint8* CGCToGCMsgMasterAck::SerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const {
    // optional uint32 dir_index = 1;
    if (_has_bit(0)) {
      target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->dir_index(), target);
    }
    
    // optional string machine_name = 3;
    if (_has_bit(1)) {
      ::google::protobuf::internal::WireFormat::VerifyUTF8String(
        this->machine_name().data(), this->machine_name().length(),
        ::google::protobuf::internal::WireFormat::SERIALIZE);
      target =
        ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
          3, this->machine_name(), target);
    }
    
    // optional string process_name = 4;
    if (_has_bit(2)) {
      ::google::protobuf::internal::WireFormat::VerifyUTF8String(
        this->process_name().data(), this->process_name().length(),
        ::google::protobuf::internal::WireFormat::SERIALIZE);
      target =
        ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
          4, this->process_name(), target);
    }
    
    // repeated uint32 type_instances = 5;
    for (int i = 0; i < this->type_instances_size(); i++) {
      target = ::google::protobuf::internal::WireFormatLite::
        WriteUInt32ToArray(5, this->type_instances(i), target);
    }
    
    if (!unknown_fields().empty()) {
      target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
          unknown_fields(), target);
    }
    return target;
  }
  
  int CGCToGCMsgMasterAck::ByteSize() const {
    int total_size = 0;
    
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      // optional uint32 dir_index = 1;
      if (has_dir_index()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormatLite::UInt32Size(
            this->dir_index());
      }
      
      // optional string machine_name = 3;
      if (has_machine_name()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormatLite::StringSize(
            this->machine_name());
      }
      
      // optional string process_name = 4;
      if (has_process_name()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormatLite::StringSize(
            this->process_name());
      }
      
    }
    // repeated uint32 type_instances = 5;
    {
      int data_size = 0;
      for (int i = 0; i < this->type_instances_size(); i++) {
        data_size += ::google::protobuf::internal::WireFormatLite::
          UInt32Size(this->type_instances(i));
      }
      total_size += 1 * this->type_instances_size() + data_size;
    }
    
    if (!unknown_fields().empty()) {
      total_size +=
        ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
          unknown_fields());
    }
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = total_size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
    return total_size;
  }
  
  void CGCToGCMsgMasterAck::MergeFrom(const ::google::protobuf::Message& from) {
    GOOGLE_CHECK_NE(&from, this);
    const CGCToGCMsgMasterAck* source =
      ::google::protobuf::internal::dynamic_cast_if_available<const CGCToGCMsgMasterAck*>(
        &from);
    if (source == NULL) {
      ::google::protobuf::internal::ReflectionOps::Merge(from, this);
    } else {
      MergeFrom(*source);
    }
  }
  
  void CGCToGCMsgMasterAck::MergeFrom(const CGCToGCMsgMasterAck& from) {
    GOOGLE_CHECK_NE(&from, this);
    type_instances_.MergeFrom(from.type_instances_);
    if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      if (from._has_bit(0)) {
        set_dir_index(from.dir_index());
      }
      if (from._has_bit(1)) {
        set_machine_name(from.machine_name());
      }
      if (from._has_bit(2)) {
        set_process_name(from.process_name());
      }
    }
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
  
  void CGCToGCMsgMasterAck::CopyFrom(const ::google::protobuf::Message& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void CGCToGCMsgMasterAck::CopyFrom(const CGCToGCMsgMasterAck& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  bool CGCToGCMsgMasterAck::IsInitialized() const {
    
    return true;
  }
  
  void CGCToGCMsgMasterAck::Swap(CGCToGCMsgMasterAck* other) {
    if (other != this) {
      std::swap(dir_index_, other->dir_index_);
      std::swap(machine_name_, other->machine_name_);
      std::swap(process_name_, other->process_name_);
      type_instances_.Swap(&other->type_instances_);
      std::swap(_has_bits_[0], other->_has_bits_[0]);
      _unknown_fields_.Swap(&other->_unknown_fields_);
      std::swap(_cached_size_, other->_cached_size_);
    }
  }
  
  ::google::protobuf::Metadata CGCToGCMsgMasterAck::GetMetadata() const {
    protobuf_AssignDescriptorsOnce();
    ::google::protobuf::Metadata metadata;
    metadata.descriptor = CGCToGCMsgMasterAck_descriptor_;
    metadata.reflection = CGCToGCMsgMasterAck_reflection_;
    return metadata;
  }
  
  
  // ===================================================================
  
  #ifndef _MSC_VER
  const int CGCToGCMsgMasterAck_Response::kEresultFieldNumber;
  #endif  // !_MSC_VER
  
  CGCToGCMsgMasterAck_Response::CGCToGCMsgMasterAck_Response()
    : ::google::protobuf::Message() {
    SharedCtor();
  }
  
  void CGCToGCMsgMasterAck_Response::InitAsDefaultInstance() {
  }
  
  CGCToGCMsgMasterAck_Response::CGCToGCMsgMasterAck_Response(const CGCToGCMsgMasterAck_Response& from)
    : ::google::protobuf::Message() {
    SharedCtor();
    MergeFrom(from);
  }
  
  void CGCToGCMsgMasterAck_Response::SharedCtor() {
    _cached_size_ = 0;
    eresult_ = 2;
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
  }
  
  CGCToGCMsgMasterAck_Response::~CGCToGCMsgMasterAck_Response() {
    SharedDtor();
  }
  
  void CGCToGCMsgMasterAck_Response::SharedDtor() {
    if (this != default_instance_) {
    }
  }
  
  void CGCToGCMsgMasterAck_Response::SetCachedSize(int size) const {
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
  }
  const ::google::protobuf::Descriptor* CGCToGCMsgMasterAck_Response::descriptor() {
    protobuf_AssignDescriptorsOnce();
    return CGCToGCMsgMasterAck_Response_descriptor_;
  }
  
  const CGCToGCMsgMasterAck_Response& CGCToGCMsgMasterAck_Response::default_instance() {
    if (default_instance_ == NULL) protobuf_AddDesc_gcsdk_5fgcmessages_2eproto();  return *default_instance_;
  }
  
  CGCToGCMsgMasterAck_Response* CGCToGCMsgMasterAck_Response::default_instance_ = NULL;
  
  CGCToGCMsgMasterAck_Response* CGCToGCMsgMasterAck_Response::New() const {
    return new CGCToGCMsgMasterAck_Response;
  }
  
  void CGCToGCMsgMasterAck_Response::Clear() {
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      eresult_ = 2;
    }
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
    mutable_unknown_fields()->Clear();
  }
  
  bool CGCToGCMsgMasterAck_Response::MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) {
  #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
    ::google::protobuf::uint32 tag;
    while ((tag = input->ReadTag()) != 0) {
      switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
        // optional int32 eresult = 1 [default = 2];
        case 1: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                   input, &eresult_)));
            _set_bit(0);
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectAtEnd()) return true;
          break;
        }
        
        default: {
        handle_uninterpreted:
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
            return true;
          }
          DO_(::google::protobuf::internal::WireFormat::SkipField(
                input, tag, mutable_unknown_fields()));
          break;
        }
      }
    }
    return true;
  #undef DO_
  }
  
  void CGCToGCMsgMasterAck_Response::SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const {
    // optional int32 eresult = 1 [default = 2];
    if (_has_bit(0)) {
      ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->eresult(), output);
    }
    
    if (!unknown_fields().empty()) {
      ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
          unknown_fields(), output);
    }
  }
  
  ::google::protobuf::uint8* CGCToGCMsgMasterAck_Response::SerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const {
    // optional int32 eresult = 1 [default = 2];
    if (_has_bit(0)) {
      target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->eresult(), target);
    }
    
    if (!unknown_fields().empty()) {
      target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
          unknown_fields(), target);
    }
    return target;
  }
  
  int CGCToGCMsgMasterAck_Response::ByteSize() const {
    int total_size = 0;
    
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      // optional int32 eresult = 1 [default = 2];
      if (has_eresult()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormatLite::Int32Size(
            this->eresult());
      }
      
    }
    if (!unknown_fields().empty()) {
      total_size +=
        ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
          unknown_fields());
    }
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = total_size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
    return total_size;
  }
  
  void CGCToGCMsgMasterAck_Response::MergeFrom(const ::google::protobuf::Message& from) {
    GOOGLE_CHECK_NE(&from, this);
    const CGCToGCMsgMasterAck_Response* source =
      ::google::protobuf::internal::dynamic_cast_if_available<const CGCToGCMsgMasterAck_Response*>(
        &from);
    if (source == NULL) {
      ::google::protobuf::internal::ReflectionOps::Merge(from, this);
    } else {
      MergeFrom(*source);
    }
  }
  
  void CGCToGCMsgMasterAck_Response::MergeFrom(const CGCToGCMsgMasterAck_Response& from) {
    GOOGLE_CHECK_NE(&from, this);
    if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      if (from._has_bit(0)) {
        set_eresult(from.eresult());
      }
    }
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
  
  void CGCToGCMsgMasterAck_Response::CopyFrom(const ::google::protobuf::Message& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void CGCToGCMsgMasterAck_Response::CopyFrom(const CGCToGCMsgMasterAck_Response& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  bool CGCToGCMsgMasterAck_Response::IsInitialized() const {
    
    return true;
  }
  
  void CGCToGCMsgMasterAck_Response::Swap(CGCToGCMsgMasterAck_Response* other) {
    if (other != this) {
      std::swap(eresult_, other->eresult_);
      std::swap(_has_bits_[0], other->_has_bits_[0]);
      _unknown_fields_.Swap(&other->_unknown_fields_);
      std::swap(_cached_size_, other->_cached_size_);
    }
  }
  
  ::google::protobuf::Metadata CGCToGCMsgMasterAck_Response::GetMetadata() const {
    protobuf_AssignDescriptorsOnce();
    ::google::protobuf::Metadata metadata;
    metadata.descriptor = CGCToGCMsgMasterAck_Response_descriptor_;
    metadata.reflection = CGCToGCMsgMasterAck_Response_reflection_;
    return metadata;
  }
  
  
  // ===================================================================
  
  const ::std::string CGCToGCMsgMasterStartupComplete_GCInfo::_default_machine_name_;
  #ifndef _MSC_VER
  const int CGCToGCMsgMasterStartupComplete_GCInfo::kDirIndexFieldNumber;
  const int CGCToGCMsgMasterStartupComplete_GCInfo::kMachineNameFieldNumber;
  #endif  // !_MSC_VER
  
  CGCToGCMsgMasterStartupComplete_GCInfo::CGCToGCMsgMasterStartupComplete_GCInfo()
    : ::google::protobuf::Message() {
    SharedCtor();
  }
  
  void CGCToGCMsgMasterStartupComplete_GCInfo::InitAsDefaultInstance() {
  }
  
  CGCToGCMsgMasterStartupComplete_GCInfo::CGCToGCMsgMasterStartupComplete_GCInfo(const CGCToGCMsgMasterStartupComplete_GCInfo& from)
    : ::google::protobuf::Message() {
    SharedCtor();
    MergeFrom(from);
  }
  
  void CGCToGCMsgMasterStartupComplete_GCInfo::SharedCtor() {
    _cached_size_ = 0;
    dir_index_ = 0u;
    machine_name_ = const_cast< ::std::string*>(&_default_machine_name_);
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
  }
  
  CGCToGCMsgMasterStartupComplete_GCInfo::~CGCToGCMsgMasterStartupComplete_GCInfo() {
    SharedDtor();
  }
  
  void CGCToGCMsgMasterStartupComplete_GCInfo::SharedDtor() {
    if (machine_name_ != &_default_machine_name_) {
      delete machine_name_;
    }
    if (this != default_instance_) {
    }
  }
  
  void CGCToGCMsgMasterStartupComplete_GCInfo::SetCachedSize(int size) const {
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
  }
  const ::google::protobuf::Descriptor* CGCToGCMsgMasterStartupComplete_GCInfo::descriptor() {
    protobuf_AssignDescriptorsOnce();
    return CGCToGCMsgMasterStartupComplete_GCInfo_descriptor_;
  }
  
  const CGCToGCMsgMasterStartupComplete_GCInfo& CGCToGCMsgMasterStartupComplete_GCInfo::default_instance() {
    if (default_instance_ == NULL) protobuf_AddDesc_gcsdk_5fgcmessages_2eproto();  return *default_instance_;
  }
  
  CGCToGCMsgMasterStartupComplete_GCInfo* CGCToGCMsgMasterStartupComplete_GCInfo::default_instance_ = NULL;
  
  CGCToGCMsgMasterStartupComplete_GCInfo* CGCToGCMsgMasterStartupComplete_GCInfo::New() const {
    return new CGCToGCMsgMasterStartupComplete_GCInfo;
  }
  
  void CGCToGCMsgMasterStartupComplete_GCInfo::Clear() {
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      dir_index_ = 0u;
      if (_has_bit(1)) {
        if (machine_name_ != &_default_machine_name_) {
          machine_name_->clear();
        }
      }
    }
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
    mutable_unknown_fields()->Clear();
  }
  
  bool CGCToGCMsgMasterStartupComplete_GCInfo::MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) {
  #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
    ::google::protobuf::uint32 tag;
    while ((tag = input->ReadTag()) != 0) {
      switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
        // optional uint32 dir_index = 1;
        case 1: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                   input, &dir_index_)));
            _set_bit(0);
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectTag(18)) goto parse_machine_name;
          break;
        }
        
        // optional string machine_name = 2;
        case 2: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
           parse_machine_name:
            DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                  input, this->mutable_machine_name()));
            ::google::protobuf::internal::WireFormat::VerifyUTF8String(
              this->machine_name().data(), this->machine_name().length(),
              ::google::protobuf::internal::WireFormat::PARSE);
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectAtEnd()) return true;
          break;
        }
        
        default: {
        handle_uninterpreted:
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
            return true;
          }
          DO_(::google::protobuf::internal::WireFormat::SkipField(
                input, tag, mutable_unknown_fields()));
          break;
        }
      }
    }
    return true;
  #undef DO_
  }
  
  void CGCToGCMsgMasterStartupComplete_GCInfo::SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const {
    // optional uint32 dir_index = 1;
    if (_has_bit(0)) {
      ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->dir_index(), output);
    }
    
    // optional string machine_name = 2;
    if (_has_bit(1)) {
      ::google::protobuf::internal::WireFormat::VerifyUTF8String(
        this->machine_name().data(), this->machine_name().length(),
        ::google::protobuf::internal::WireFormat::SERIALIZE);
      ::google::protobuf::internal::WireFormatLite::WriteString(
        2, this->machine_name(), output);
    }
    
    if (!unknown_fields().empty()) {
      ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
          unknown_fields(), output);
    }
  }
  
  ::google::protobuf::uint8* CGCToGCMsgMasterStartupComplete_GCInfo::SerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const {
    // optional uint32 dir_index = 1;
    if (_has_bit(0)) {
      target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->dir_index(), target);
    }
    
    // optional string machine_name = 2;
    if (_has_bit(1)) {
      ::google::protobuf::internal::WireFormat::VerifyUTF8String(
        this->machine_name().data(), this->machine_name().length(),
        ::google::protobuf::internal::WireFormat::SERIALIZE);
      target =
        ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
          2, this->machine_name(), target);
    }
    
    if (!unknown_fields().empty()) {
      target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
          unknown_fields(), target);
    }
    return target;
  }
  
  int CGCToGCMsgMasterStartupComplete_GCInfo::ByteSize() const {
    int total_size = 0;
    
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      // optional uint32 dir_index = 1;
      if (has_dir_index()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormatLite::UInt32Size(
            this->dir_index());
      }
      
      // optional string machine_name = 2;
      if (has_machine_name()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormatLite::StringSize(
            this->machine_name());
      }
      
    }
    if (!unknown_fields().empty()) {
      total_size +=
        ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
          unknown_fields());
    }
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = total_size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
    return total_size;
  }
  
  void CGCToGCMsgMasterStartupComplete_GCInfo::MergeFrom(const ::google::protobuf::Message& from) {
    GOOGLE_CHECK_NE(&from, this);
    const CGCToGCMsgMasterStartupComplete_GCInfo* source =
      ::google::protobuf::internal::dynamic_cast_if_available<const CGCToGCMsgMasterStartupComplete_GCInfo*>(
        &from);
    if (source == NULL) {
      ::google::protobuf::internal::ReflectionOps::Merge(from, this);
    } else {
      MergeFrom(*source);
    }
  }
  
  void CGCToGCMsgMasterStartupComplete_GCInfo::MergeFrom(const CGCToGCMsgMasterStartupComplete_GCInfo& from) {
    GOOGLE_CHECK_NE(&from, this);
    if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      if (from._has_bit(0)) {
        set_dir_index(from.dir_index());
      }
      if (from._has_bit(1)) {
        set_machine_name(from.machine_name());
      }
    }
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
  
  void CGCToGCMsgMasterStartupComplete_GCInfo::CopyFrom(const ::google::protobuf::Message& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void CGCToGCMsgMasterStartupComplete_GCInfo::CopyFrom(const CGCToGCMsgMasterStartupComplete_GCInfo& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  bool CGCToGCMsgMasterStartupComplete_GCInfo::IsInitialized() const {
    
    return true;
  }
  
  void CGCToGCMsgMasterStartupComplete_GCInfo::Swap(CGCToGCMsgMasterStartupComplete_GCInfo* other) {
    if (other != this) {
      std::swap(dir_index_, other->dir_index_);
      std::swap(machine_name_, other->machine_name_);
      std::swap(_has_bits_[0], other->_has_bits_[0]);
      _unknown_fields_.Swap(&other->_unknown_fields_);
      std::swap(_cached_size_, other->_cached_size_);
    }
  }
  
  ::google::protobuf::Metadata CGCToGCMsgMasterStartupComplete_GCInfo::GetMetadata() const {
    protobuf_AssignDescriptorsOnce();
    ::google::protobuf::Metadata metadata;
    metadata.descriptor = CGCToGCMsgMasterStartupComplete_GCInfo_descriptor_;
    metadata.reflection = CGCToGCMsgMasterStartupComplete_GCInfo_reflection_;
    return metadata;
  }
  
  
  // -------------------------------------------------------------------
  
  #ifndef _MSC_VER
  const int CGCToGCMsgMasterStartupComplete::kGcInfoFieldNumber;
  #endif  // !_MSC_VER
  
  CGCToGCMsgMasterStartupComplete::CGCToGCMsgMasterStartupComplete()
    : ::google::protobuf::Message() {
    SharedCtor();
  }
  
  void CGCToGCMsgMasterStartupComplete::InitAsDefaultInstance() {
  }
  
  CGCToGCMsgMasterStartupComplete::CGCToGCMsgMasterStartupComplete(const CGCToGCMsgMasterStartupComplete& from)
    : ::google::protobuf::Message() {
    SharedCtor();
    MergeFrom(from);
  }
  
  void CGCToGCMsgMasterStartupComplete::SharedCtor() {
    _cached_size_ = 0;
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
  }
  
  CGCToGCMsgMasterStartupComplete::~CGCToGCMsgMasterStartupComplete() {
    SharedDtor();
  }
  
  void CGCToGCMsgMasterStartupComplete::SharedDtor() {
    if (this != default_instance_) {
    }
  }
  
  void CGCToGCMsgMasterStartupComplete::SetCachedSize(int size) const {
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
  }
  const ::google::protobuf::Descriptor* CGCToGCMsgMasterStartupComplete::descriptor() {
    protobuf_AssignDescriptorsOnce();
    return CGCToGCMsgMasterStartupComplete_descriptor_;
  }
  
  const CGCToGCMsgMasterStartupComplete& CGCToGCMsgMasterStartupComplete::default_instance() {
    if (default_instance_ == NULL) protobuf_AddDesc_gcsdk_5fgcmessages_2eproto();  return *default_instance_;
  }
  
  CGCToGCMsgMasterStartupComplete* CGCToGCMsgMasterStartupComplete::default_instance_ = NULL;
  
  CGCToGCMsgMasterStartupComplete* CGCToGCMsgMasterStartupComplete::New() const {
    return new CGCToGCMsgMasterStartupComplete;
  }
  
  void CGCToGCMsgMasterStartupComplete::Clear() {
    gc_info_.Clear();
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
    mutable_unknown_fields()->Clear();
  }
  
  bool CGCToGCMsgMasterStartupComplete::MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) {
  #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
    ::google::protobuf::uint32 tag;
    while ((tag = input->ReadTag()) != 0) {
      switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
        // repeated .CGCToGCMsgMasterStartupComplete.GCInfo gc_info = 1;
        case 1: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
           parse_gc_info:
            DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                  input, add_gc_info()));
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectTag(10)) goto parse_gc_info;
          if (input->ExpectAtEnd()) return true;
          break;
        }
        
        default: {
        handle_uninterpreted:
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
            return true;
          }
          DO_(::google::protobuf::internal::WireFormat::SkipField(
                input, tag, mutable_unknown_fields()));
          break;
        }
      }
    }
    return true;
  #undef DO_
  }
  
  void CGCToGCMsgMasterStartupComplete::SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const {
    // repeated .CGCToGCMsgMasterStartupComplete.GCInfo gc_info = 1;
    for (int i = 0; i < this->gc_info_size(); i++) {
      ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
        1, this->gc_info(i), output);
    }
    
    if (!unknown_fields().empty()) {
      ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
          unknown_fields(), output);
    }
  }
  
  ::google::protobuf::uint8* CGCToGCMsgMasterStartupComplete::SerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const {
    // repeated .CGCToGCMsgMasterStartupComplete.GCInfo gc_info = 1;
    for (int i = 0; i < this->gc_info_size(); i++) {
      target = ::google::protobuf::internal::WireFormatLite::
        WriteMessageNoVirtualToArray(
          1, this->gc_info(i), target);
    }
    
    if (!unknown_fields().empty()) {
      target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
          unknown_fields(), target);
    }
    return target;
  }
  
  int CGCToGCMsgMasterStartupComplete::ByteSize() const {
    int total_size = 0;
    
    // repeated .CGCToGCMsgMasterStartupComplete.GCInfo gc_info = 1;
    total_size += 1 * this->gc_info_size();
    for (int i = 0; i < this->gc_info_size(); i++) {
      total_size +=
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->gc_info(i));
    }
    
    if (!unknown_fields().empty()) {
      total_size +=
        ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
          unknown_fields());
    }
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = total_size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
    return total_size;
  }
  
  void CGCToGCMsgMasterStartupComplete::MergeFrom(const ::google::protobuf::Message& from) {
    GOOGLE_CHECK_NE(&from, this);
    const CGCToGCMsgMasterStartupComplete* source =
      ::google::protobuf::internal::dynamic_cast_if_available<const CGCToGCMsgMasterStartupComplete*>(
        &from);
    if (source == NULL) {
      ::google::protobuf::internal::ReflectionOps::Merge(from, this);
    } else {
      MergeFrom(*source);
    }
  }
  
  void CGCToGCMsgMasterStartupComplete::MergeFrom(const CGCToGCMsgMasterStartupComplete& from) {
    GOOGLE_CHECK_NE(&from, this);
    gc_info_.MergeFrom(from.gc_info_);
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
  
  void CGCToGCMsgMasterStartupComplete::CopyFrom(const ::google::protobuf::Message& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void CGCToGCMsgMasterStartupComplete::CopyFrom(const CGCToGCMsgMasterStartupComplete& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  bool CGCToGCMsgMasterStartupComplete::IsInitialized() const {
    
    return true;
  }
  
  void CGCToGCMsgMasterStartupComplete::Swap(CGCToGCMsgMasterStartupComplete* other) {
    if (other != this) {
      gc_info_.Swap(&other->gc_info_);
      std::swap(_has_bits_[0], other->_has_bits_[0]);
      _unknown_fields_.Swap(&other->_unknown_fields_);
      std::swap(_cached_size_, other->_cached_size_);
    }
  }
  
  ::google::protobuf::Metadata CGCToGCMsgMasterStartupComplete::GetMetadata() const {
    protobuf_AssignDescriptorsOnce();
    ::google::protobuf::Metadata metadata;
    metadata.descriptor = CGCToGCMsgMasterStartupComplete_descriptor_;
    metadata.reflection = CGCToGCMsgMasterStartupComplete_reflection_;
    return metadata;
  }
  
  
  // ===================================================================
  
  const ::std::string CGCToGCMsgRouted::_default_net_message_;
  #ifndef _MSC_VER
  const int CGCToGCMsgRouted::kMsgTypeFieldNumber;
  const int CGCToGCMsgRouted::kSenderIdFieldNumber;
  const int CGCToGCMsgRouted::kNetMessageFieldNumber;
  #endif  // !_MSC_VER
  
  CGCToGCMsgRouted::CGCToGCMsgRouted()
    : ::google::protobuf::Message() {
    SharedCtor();
  }
  
  void CGCToGCMsgRouted::InitAsDefaultInstance() {
  }
  
  CGCToGCMsgRouted::CGCToGCMsgRouted(const CGCToGCMsgRouted& from)
    : ::google::protobuf::Message() {
    SharedCtor();
    MergeFrom(from);
  }
  
  void CGCToGCMsgRouted::SharedCtor() {
    _cached_size_ = 0;
    msg_type_ = 0u;
    sender_id_ = GOOGLE_ULONGLONG(0);
    net_message_ = const_cast< ::std::string*>(&_default_net_message_);
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
  }
  
  CGCToGCMsgRouted::~CGCToGCMsgRouted() {
    SharedDtor();
  }
  
  void CGCToGCMsgRouted::SharedDtor() {
    if (net_message_ != &_default_net_message_) {
      delete net_message_;
    }
    if (this != default_instance_) {
    }
  }
  
  void CGCToGCMsgRouted::SetCachedSize(int size) const {
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
  }
  const ::google::protobuf::Descriptor* CGCToGCMsgRouted::descriptor() {
    protobuf_AssignDescriptorsOnce();
    return CGCToGCMsgRouted_descriptor_;
  }
  
  const CGCToGCMsgRouted& CGCToGCMsgRouted::default_instance() {
    if (default_instance_ == NULL) protobuf_AddDesc_gcsdk_5fgcmessages_2eproto();  return *default_instance_;
  }
  
  CGCToGCMsgRouted* CGCToGCMsgRouted::default_instance_ = NULL;
  
  CGCToGCMsgRouted* CGCToGCMsgRouted::New() const {
    return new CGCToGCMsgRouted;
  }
  
  void CGCToGCMsgRouted::Clear() {
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      msg_type_ = 0u;
      sender_id_ = GOOGLE_ULONGLONG(0);
      if (_has_bit(2)) {
        if (net_message_ != &_default_net_message_) {
          net_message_->clear();
        }
      }
    }
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
    mutable_unknown_fields()->Clear();
  }
  
  bool CGCToGCMsgRouted::MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) {
  #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
    ::google::protobuf::uint32 tag;
    while ((tag = input->ReadTag()) != 0) {
      switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
        // optional uint32 msg_type = 1;
        case 1: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                   input, &msg_type_)));
            _set_bit(0);
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectTag(17)) goto parse_sender_id;
          break;
        }
        
        // optional fixed64 sender_id = 2;
        case 2: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
           parse_sender_id:
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                   input, &sender_id_)));
            _set_bit(1);
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectTag(26)) goto parse_net_message;
          break;
        }
        
        // optional bytes net_message = 3;
        case 3: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
           parse_net_message:
            DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                  input, this->mutable_net_message()));
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectAtEnd()) return true;
          break;
        }
        
        default: {
        handle_uninterpreted:
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
            return true;
          }
          DO_(::google::protobuf::internal::WireFormat::SkipField(
                input, tag, mutable_unknown_fields()));
          break;
        }
      }
    }
    return true;
  #undef DO_
  }
  
  void CGCToGCMsgRouted::SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const {
    // optional uint32 msg_type = 1;
    if (_has_bit(0)) {
      ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->msg_type(), output);
    }
    
    // optional fixed64 sender_id = 2;
    if (_has_bit(1)) {
      ::google::protobuf::internal::WireFormatLite::WriteFixed64(2, this->sender_id(), output);
    }
    
    // optional bytes net_message = 3;
    if (_has_bit(2)) {
      ::google::protobuf::internal::WireFormatLite::WriteBytes(
        3, this->net_message(), output);
    }
    
    if (!unknown_fields().empty()) {
      ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
          unknown_fields(), output);
    }
  }
  
  ::google::protobuf::uint8* CGCToGCMsgRouted::SerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const {
    // optional uint32 msg_type = 1;
    if (_has_bit(0)) {
      target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->msg_type(), target);
    }
    
    // optional fixed64 sender_id = 2;
    if (_has_bit(1)) {
      target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(2, this->sender_id(), target);
    }
    
    // optional bytes net_message = 3;
    if (_has_bit(2)) {
      target =
        ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
          3, this->net_message(), target);
    }
    
    if (!unknown_fields().empty()) {
      target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
          unknown_fields(), target);
    }
    return target;
  }
  
  int CGCToGCMsgRouted::ByteSize() const {
    int total_size = 0;
    
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      // optional uint32 msg_type = 1;
      if (has_msg_type()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormatLite::UInt32Size(
            this->msg_type());
      }
      
      // optional fixed64 sender_id = 2;
      if (has_sender_id()) {
        total_size += 1 + 8;
      }
      
      // optional bytes net_message = 3;
      if (has_net_message()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormatLite::BytesSize(
            this->net_message());
      }
      
    }
    if (!unknown_fields().empty()) {
      total_size +=
        ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
          unknown_fields());
    }
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = total_size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
    return total_size;
  }
  
  void CGCToGCMsgRouted::MergeFrom(const ::google::protobuf::Message& from) {
    GOOGLE_CHECK_NE(&from, this);
    const CGCToGCMsgRouted* source =
      ::google::protobuf::internal::dynamic_cast_if_available<const CGCToGCMsgRouted*>(
        &from);
    if (source == NULL) {
      ::google::protobuf::internal::ReflectionOps::Merge(from, this);
    } else {
      MergeFrom(*source);
    }
  }
  
  void CGCToGCMsgRouted::MergeFrom(const CGCToGCMsgRouted& from) {
    GOOGLE_CHECK_NE(&from, this);
    if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      if (from._has_bit(0)) {
        set_msg_type(from.msg_type());
      }
      if (from._has_bit(1)) {
        set_sender_id(from.sender_id());
      }
      if (from._has_bit(2)) {
        set_net_message(from.net_message());
      }
    }
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
  
  void CGCToGCMsgRouted::CopyFrom(const ::google::protobuf::Message& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void CGCToGCMsgRouted::CopyFrom(const CGCToGCMsgRouted& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  bool CGCToGCMsgRouted::IsInitialized() const {
    
    return true;
  }
  
  void CGCToGCMsgRouted::Swap(CGCToGCMsgRouted* other) {
    if (other != this) {
      std::swap(msg_type_, other->msg_type_);
      std::swap(sender_id_, other->sender_id_);
      std::swap(net_message_, other->net_message_);
      std::swap(_has_bits_[0], other->_has_bits_[0]);
      _unknown_fields_.Swap(&other->_unknown_fields_);
      std::swap(_cached_size_, other->_cached_size_);
    }
  }
  
  ::google::protobuf::Metadata CGCToGCMsgRouted::GetMetadata() const {
    protobuf_AssignDescriptorsOnce();
    ::google::protobuf::Metadata metadata;
    metadata.descriptor = CGCToGCMsgRouted_descriptor_;
    metadata.reflection = CGCToGCMsgRouted_reflection_;
    return metadata;
  }
  
  
  // ===================================================================
  
  const ::std::string CGCToGCMsgRoutedReply::_default_net_message_;
  #ifndef _MSC_VER
  const int CGCToGCMsgRoutedReply::kMsgTypeFieldNumber;
  const int CGCToGCMsgRoutedReply::kNetMessageFieldNumber;
  #endif  // !_MSC_VER
  
  CGCToGCMsgRoutedReply::CGCToGCMsgRoutedReply()
    : ::google::protobuf::Message() {
    SharedCtor();
  }
  
  void CGCToGCMsgRoutedReply::InitAsDefaultInstance() {
  }
  
  CGCToGCMsgRoutedReply::CGCToGCMsgRoutedReply(const CGCToGCMsgRoutedReply& from)
    : ::google::protobuf::Message() {
    SharedCtor();
    MergeFrom(from);
  }
  
  void CGCToGCMsgRoutedReply::SharedCtor() {
    _cached_size_ = 0;
    msg_type_ = 0u;
    net_message_ = const_cast< ::std::string*>(&_default_net_message_);
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
  }
  
  CGCToGCMsgRoutedReply::~CGCToGCMsgRoutedReply() {
    SharedDtor();
  }
  
  void CGCToGCMsgRoutedReply::SharedDtor() {
    if (net_message_ != &_default_net_message_) {
      delete net_message_;
    }
    if (this != default_instance_) {
    }
  }
  
  void CGCToGCMsgRoutedReply::SetCachedSize(int size) const {
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
  }
  const ::google::protobuf::Descriptor* CGCToGCMsgRoutedReply::descriptor() {
    protobuf_AssignDescriptorsOnce();
    return CGCToGCMsgRoutedReply_descriptor_;
  }
  
  const CGCToGCMsgRoutedReply& CGCToGCMsgRoutedReply::default_instance() {
    if (default_instance_ == NULL) protobuf_AddDesc_gcsdk_5fgcmessages_2eproto();  return *default_instance_;
  }
  
  CGCToGCMsgRoutedReply* CGCToGCMsgRoutedReply::default_instance_ = NULL;
  
  CGCToGCMsgRoutedReply* CGCToGCMsgRoutedReply::New() const {
    return new CGCToGCMsgRoutedReply;
  }
  
  void CGCToGCMsgRoutedReply::Clear() {
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      msg_type_ = 0u;
      if (_has_bit(1)) {
        if (net_message_ != &_default_net_message_) {
          net_message_->clear();
        }
      }
    }
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
    mutable_unknown_fields()->Clear();
  }
  
  bool CGCToGCMsgRoutedReply::MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) {
  #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
    ::google::protobuf::uint32 tag;
    while ((tag = input->ReadTag()) != 0) {
      switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
        // optional uint32 msg_type = 1;
        case 1: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                   input, &msg_type_)));
            _set_bit(0);
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectTag(18)) goto parse_net_message;
          break;
        }
        
        // optional bytes net_message = 2;
        case 2: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
           parse_net_message:
            DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                  input, this->mutable_net_message()));
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectAtEnd()) return true;
          break;
        }
        
        default: {
        handle_uninterpreted:
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
            return true;
          }
          DO_(::google::protobuf::internal::WireFormat::SkipField(
                input, tag, mutable_unknown_fields()));
          break;
        }
      }
    }
    return true;
  #undef DO_
  }
  
  void CGCToGCMsgRoutedReply::SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const {
    // optional uint32 msg_type = 1;
    if (_has_bit(0)) {
      ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->msg_type(), output);
    }
    
    // optional bytes net_message = 2;
    if (_has_bit(1)) {
      ::google::protobuf::internal::WireFormatLite::WriteBytes(
        2, this->net_message(), output);
    }
    
    if (!unknown_fields().empty()) {
      ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
          unknown_fields(), output);
    }
  }
  
  ::google::protobuf::uint8* CGCToGCMsgRoutedReply::SerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const {
    // optional uint32 msg_type = 1;
    if (_has_bit(0)) {
      target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->msg_type(), target);
    }
    
    // optional bytes net_message = 2;
    if (_has_bit(1)) {
      target =
        ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
          2, this->net_message(), target);
    }
    
    if (!unknown_fields().empty()) {
      target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
          unknown_fields(), target);
    }
    return target;
  }
  
  int CGCToGCMsgRoutedReply::ByteSize() const {
    int total_size = 0;
    
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      // optional uint32 msg_type = 1;
      if (has_msg_type()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormatLite::UInt32Size(
            this->msg_type());
      }
      
      // optional bytes net_message = 2;
      if (has_net_message()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormatLite::BytesSize(
            this->net_message());
      }
      
    }
    if (!unknown_fields().empty()) {
      total_size +=
        ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
          unknown_fields());
    }
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = total_size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
    return total_size;
  }
  
  void CGCToGCMsgRoutedReply::MergeFrom(const ::google::protobuf::Message& from) {
    GOOGLE_CHECK_NE(&from, this);
    const CGCToGCMsgRoutedReply* source =
      ::google::protobuf::internal::dynamic_cast_if_available<const CGCToGCMsgRoutedReply*>(
        &from);
    if (source == NULL) {
      ::google::protobuf::internal::ReflectionOps::Merge(from, this);
    } else {
      MergeFrom(*source);
    }
  }
  
  void CGCToGCMsgRoutedReply::MergeFrom(const CGCToGCMsgRoutedReply& from) {
    GOOGLE_CHECK_NE(&from, this);
    if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      if (from._has_bit(0)) {
        set_msg_type(from.msg_type());
      }
      if (from._has_bit(1)) {
        set_net_message(from.net_message());
      }
    }
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
  
  void CGCToGCMsgRoutedReply::CopyFrom(const ::google::protobuf::Message& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void CGCToGCMsgRoutedReply::CopyFrom(const CGCToGCMsgRoutedReply& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  bool CGCToGCMsgRoutedReply::IsInitialized() const {
    
    return true;
  }
  
  void CGCToGCMsgRoutedReply::Swap(CGCToGCMsgRoutedReply* other) {
    if (other != this) {
      std::swap(msg_type_, other->msg_type_);
      std::swap(net_message_, other->net_message_);
      std::swap(_has_bits_[0], other->_has_bits_[0]);
      _unknown_fields_.Swap(&other->_unknown_fields_);
      std::swap(_cached_size_, other->_cached_size_);
    }
  }
  
  ::google::protobuf::Metadata CGCToGCMsgRoutedReply::GetMetadata() const {
    protobuf_AssignDescriptorsOnce();
    ::google::protobuf::Metadata metadata;
    metadata.descriptor = CGCToGCMsgRoutedReply_descriptor_;
    metadata.reflection = CGCToGCMsgRoutedReply_reflection_;
    return metadata;
  }
  
  
  // ===================================================================
  
  #ifndef _MSC_VER
  const int CMsgGCUpdateSubGCSessionInfo_CMsgUpdate::kSteamidFieldNumber;
  const int CMsgGCUpdateSubGCSessionInfo_CMsgUpdate::kIpFieldNumber;
  const int CMsgGCUpdateSubGCSessionInfo_CMsgUpdate::kTrustedFieldNumber;
  #endif  // !_MSC_VER
  
  CMsgGCUpdateSubGCSessionInfo_CMsgUpdate::CMsgGCUpdateSubGCSessionInfo_CMsgUpdate()
    : ::google::protobuf::Message() {
    SharedCtor();
  }
  
  void CMsgGCUpdateSubGCSessionInfo_CMsgUpdate::InitAsDefaultInstance() {
  }
  
  CMsgGCUpdateSubGCSessionInfo_CMsgUpdate::CMsgGCUpdateSubGCSessionInfo_CMsgUpdate(const CMsgGCUpdateSubGCSessionInfo_CMsgUpdate& from)
    : ::google::protobuf::Message() {
    SharedCtor();
    MergeFrom(from);
  }
  
  void CMsgGCUpdateSubGCSessionInfo_CMsgUpdate::SharedCtor() {
    _cached_size_ = 0;
    steamid_ = GOOGLE_ULONGLONG(0);
    ip_ = 0u;
    trusted_ = false;
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
  }
  
  CMsgGCUpdateSubGCSessionInfo_CMsgUpdate::~CMsgGCUpdateSubGCSessionInfo_CMsgUpdate() {
    SharedDtor();
  }
  
  void CMsgGCUpdateSubGCSessionInfo_CMsgUpdate::SharedDtor() {
    if (this != default_instance_) {
    }
  }
  
  void CMsgGCUpdateSubGCSessionInfo_CMsgUpdate::SetCachedSize(int size) const {
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
  }
  const ::google::protobuf::Descriptor* CMsgGCUpdateSubGCSessionInfo_CMsgUpdate::descriptor() {
    protobuf_AssignDescriptorsOnce();
    return CMsgGCUpdateSubGCSessionInfo_CMsgUpdate_descriptor_;
  }
  
  const CMsgGCUpdateSubGCSessionInfo_CMsgUpdate& CMsgGCUpdateSubGCSessionInfo_CMsgUpdate::default_instance() {
    if (default_instance_ == NULL) protobuf_AddDesc_gcsdk_5fgcmessages_2eproto();  return *default_instance_;
  }
  
  CMsgGCUpdateSubGCSessionInfo_CMsgUpdate* CMsgGCUpdateSubGCSessionInfo_CMsgUpdate::default_instance_ = NULL;
  
  CMsgGCUpdateSubGCSessionInfo_CMsgUpdate* CMsgGCUpdateSubGCSessionInfo_CMsgUpdate::New() const {
    return new CMsgGCUpdateSubGCSessionInfo_CMsgUpdate;
  }
  
  void CMsgGCUpdateSubGCSessionInfo_CMsgUpdate::Clear() {
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      steamid_ = GOOGLE_ULONGLONG(0);
      ip_ = 0u;
      trusted_ = false;
    }
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
    mutable_unknown_fields()->Clear();
  }
  
  bool CMsgGCUpdateSubGCSessionInfo_CMsgUpdate::MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) {
  #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
    ::google::protobuf::uint32 tag;
    while ((tag = input->ReadTag()) != 0) {
      switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
        // optional fixed64 steamid = 1;
        case 1: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                   input, &steamid_)));
            _set_bit(0);
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectTag(21)) goto parse_ip;
          break;
        }
        
        // optional fixed32 ip = 2;
        case 2: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
           parse_ip:
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
                   input, &ip_)));
            _set_bit(1);
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectTag(24)) goto parse_trusted;
          break;
        }
        
        // optional bool trusted = 3;
        case 3: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
           parse_trusted:
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                   input, &trusted_)));
            _set_bit(2);
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectAtEnd()) return true;
          break;
        }
        
        default: {
        handle_uninterpreted:
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
            return true;
          }
          DO_(::google::protobuf::internal::WireFormat::SkipField(
                input, tag, mutable_unknown_fields()));
          break;
        }
      }
    }
    return true;
  #undef DO_
  }
  
  void CMsgGCUpdateSubGCSessionInfo_CMsgUpdate::SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const {
    // optional fixed64 steamid = 1;
    if (_has_bit(0)) {
      ::google::protobuf::internal::WireFormatLite::WriteFixed64(1, this->steamid(), output);
    }
    
    // optional fixed32 ip = 2;
    if (_has_bit(1)) {
      ::google::protobuf::internal::WireFormatLite::WriteFixed32(2, this->ip(), output);
    }
    
    // optional bool trusted = 3;
    if (_has_bit(2)) {
      ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->trusted(), output);
    }
    
    if (!unknown_fields().empty()) {
      ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
          unknown_fields(), output);
    }
  }
  
  ::google::protobuf::uint8* CMsgGCUpdateSubGCSessionInfo_CMsgUpdate::SerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const {
    // optional fixed64 steamid = 1;
    if (_has_bit(0)) {
      target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(1, this->steamid(), target);
    }
    
    // optional fixed32 ip = 2;
    if (_has_bit(1)) {
      target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(2, this->ip(), target);
    }
    
    // optional bool trusted = 3;
    if (_has_bit(2)) {
      target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->trusted(), target);
    }
    
    if (!unknown_fields().empty()) {
      target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
          unknown_fields(), target);
    }
    return target;
  }
  
  int CMsgGCUpdateSubGCSessionInfo_CMsgUpdate::ByteSize() const {
    int total_size = 0;
    
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      // optional fixed64 steamid = 1;
      if (has_steamid()) {
        total_size += 1 + 8;
      }
      
      // optional fixed32 ip = 2;
      if (has_ip()) {
        total_size += 1 + 4;
      }
      
      // optional bool trusted = 3;
      if (has_trusted()) {
        total_size += 1 + 1;
      }
      
    }
    if (!unknown_fields().empty()) {
      total_size +=
        ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
          unknown_fields());
    }
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = total_size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
    return total_size;
  }
  
  void CMsgGCUpdateSubGCSessionInfo_CMsgUpdate::MergeFrom(const ::google::protobuf::Message& from) {
    GOOGLE_CHECK_NE(&from, this);
    const CMsgGCUpdateSubGCSessionInfo_CMsgUpdate* source =
      ::google::protobuf::internal::dynamic_cast_if_available<const CMsgGCUpdateSubGCSessionInfo_CMsgUpdate*>(
        &from);
    if (source == NULL) {
      ::google::protobuf::internal::ReflectionOps::Merge(from, this);
    } else {
      MergeFrom(*source);
    }
  }
  
  void CMsgGCUpdateSubGCSessionInfo_CMsgUpdate::MergeFrom(const CMsgGCUpdateSubGCSessionInfo_CMsgUpdate& from) {
    GOOGLE_CHECK_NE(&from, this);
    if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      if (from._has_bit(0)) {
        set_steamid(from.steamid());
      }
      if (from._has_bit(1)) {
        set_ip(from.ip());
      }
      if (from._has_bit(2)) {
        set_trusted(from.trusted());
      }
    }
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
  
  void CMsgGCUpdateSubGCSessionInfo_CMsgUpdate::CopyFrom(const ::google::protobuf::Message& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void CMsgGCUpdateSubGCSessionInfo_CMsgUpdate::CopyFrom(const CMsgGCUpdateSubGCSessionInfo_CMsgUpdate& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  bool CMsgGCUpdateSubGCSessionInfo_CMsgUpdate::IsInitialized() const {
    
    return true;
  }
  
  void CMsgGCUpdateSubGCSessionInfo_CMsgUpdate::Swap(CMsgGCUpdateSubGCSessionInfo_CMsgUpdate* other) {
    if (other != this) {
      std::swap(steamid_, other->steamid_);
      std::swap(ip_, other->ip_);
      std::swap(trusted_, other->trusted_);
      std::swap(_has_bits_[0], other->_has_bits_[0]);
      _unknown_fields_.Swap(&other->_unknown_fields_);
      std::swap(_cached_size_, other->_cached_size_);
    }
  }
  
  ::google::protobuf::Metadata CMsgGCUpdateSubGCSessionInfo_CMsgUpdate::GetMetadata() const {
    protobuf_AssignDescriptorsOnce();
    ::google::protobuf::Metadata metadata;
    metadata.descriptor = CMsgGCUpdateSubGCSessionInfo_CMsgUpdate_descriptor_;
    metadata.reflection = CMsgGCUpdateSubGCSessionInfo_CMsgUpdate_reflection_;
    return metadata;
  }
  
  
  // -------------------------------------------------------------------
  
  #ifndef _MSC_VER
  const int CMsgGCUpdateSubGCSessionInfo::kUpdatesFieldNumber;
  #endif  // !_MSC_VER
  
  CMsgGCUpdateSubGCSessionInfo::CMsgGCUpdateSubGCSessionInfo()
    : ::google::protobuf::Message() {
    SharedCtor();
  }
  
  void CMsgGCUpdateSubGCSessionInfo::InitAsDefaultInstance() {
  }
  
  CMsgGCUpdateSubGCSessionInfo::CMsgGCUpdateSubGCSessionInfo(const CMsgGCUpdateSubGCSessionInfo& from)
    : ::google::protobuf::Message() {
    SharedCtor();
    MergeFrom(from);
  }
  
  void CMsgGCUpdateSubGCSessionInfo::SharedCtor() {
    _cached_size_ = 0;
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
  }
  
  CMsgGCUpdateSubGCSessionInfo::~CMsgGCUpdateSubGCSessionInfo() {
    SharedDtor();
  }
  
  void CMsgGCUpdateSubGCSessionInfo::SharedDtor() {
    if (this != default_instance_) {
    }
  }
  
  void CMsgGCUpdateSubGCSessionInfo::SetCachedSize(int size) const {
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
  }
  const ::google::protobuf::Descriptor* CMsgGCUpdateSubGCSessionInfo::descriptor() {
    protobuf_AssignDescriptorsOnce();
    return CMsgGCUpdateSubGCSessionInfo_descriptor_;
  }
  
  const CMsgGCUpdateSubGCSessionInfo& CMsgGCUpdateSubGCSessionInfo::default_instance() {
    if (default_instance_ == NULL) protobuf_AddDesc_gcsdk_5fgcmessages_2eproto();  return *default_instance_;
  }
  
  CMsgGCUpdateSubGCSessionInfo* CMsgGCUpdateSubGCSessionInfo::default_instance_ = NULL;
  
  CMsgGCUpdateSubGCSessionInfo* CMsgGCUpdateSubGCSessionInfo::New() const {
    return new CMsgGCUpdateSubGCSessionInfo;
  }
  
  void CMsgGCUpdateSubGCSessionInfo::Clear() {
    updates_.Clear();
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
    mutable_unknown_fields()->Clear();
  }
  
  bool CMsgGCUpdateSubGCSessionInfo::MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) {
  #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
    ::google::protobuf::uint32 tag;
    while ((tag = input->ReadTag()) != 0) {
      switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
        // repeated .CMsgGCUpdateSubGCSessionInfo.CMsgUpdate updates = 1;
        case 1: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
           parse_updates:
            DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                  input, add_updates()));
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectTag(10)) goto parse_updates;
          if (input->ExpectAtEnd()) return true;
          break;
        }
        
        default: {
        handle_uninterpreted:
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
            return true;
          }
          DO_(::google::protobuf::internal::WireFormat::SkipField(
                input, tag, mutable_unknown_fields()));
          break;
        }
      }
    }
    return true;
  #undef DO_
  }
  
  void CMsgGCUpdateSubGCSessionInfo::SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const {
    // repeated .CMsgGCUpdateSubGCSessionInfo.CMsgUpdate updates = 1;
    for (int i = 0; i < this->updates_size(); i++) {
      ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
        1, this->updates(i), output);
    }
    
    if (!unknown_fields().empty()) {
      ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
          unknown_fields(), output);
    }
  }
  
  ::google::protobuf::uint8* CMsgGCUpdateSubGCSessionInfo::SerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const {
    // repeated .CMsgGCUpdateSubGCSessionInfo.CMsgUpdate updates = 1;
    for (int i = 0; i < this->updates_size(); i++) {
      target = ::google::protobuf::internal::WireFormatLite::
        WriteMessageNoVirtualToArray(
          1, this->updates(i), target);
    }
    
    if (!unknown_fields().empty()) {
      target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
          unknown_fields(), target);
    }
    return target;
  }
  
  int CMsgGCUpdateSubGCSessionInfo::ByteSize() const {
    int total_size = 0;
    
    // repeated .CMsgGCUpdateSubGCSessionInfo.CMsgUpdate updates = 1;
    total_size += 1 * this->updates_size();
    for (int i = 0; i < this->updates_size(); i++) {
      total_size +=
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->updates(i));
    }
    
    if (!unknown_fields().empty()) {
      total_size +=
        ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
          unknown_fields());
    }
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = total_size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
    return total_size;
  }
  
  void CMsgGCUpdateSubGCSessionInfo::MergeFrom(const ::google::protobuf::Message& from) {
    GOOGLE_CHECK_NE(&from, this);
    const CMsgGCUpdateSubGCSessionInfo* source =
      ::google::protobuf::internal::dynamic_cast_if_available<const CMsgGCUpdateSubGCSessionInfo*>(
        &from);
    if (source == NULL) {
      ::google::protobuf::internal::ReflectionOps::Merge(from, this);
    } else {
      MergeFrom(*source);
    }
  }
  
  void CMsgGCUpdateSubGCSessionInfo::MergeFrom(const CMsgGCUpdateSubGCSessionInfo& from) {
    GOOGLE_CHECK_NE(&from, this);
    updates_.MergeFrom(from.updates_);
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
  
  void CMsgGCUpdateSubGCSessionInfo::CopyFrom(const ::google::protobuf::Message& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void CMsgGCUpdateSubGCSessionInfo::CopyFrom(const CMsgGCUpdateSubGCSessionInfo& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  bool CMsgGCUpdateSubGCSessionInfo::IsInitialized() const {
    
    return true;
  }
  
  void CMsgGCUpdateSubGCSessionInfo::Swap(CMsgGCUpdateSubGCSessionInfo* other) {
    if (other != this) {
      updates_.Swap(&other->updates_);
      std::swap(_has_bits_[0], other->_has_bits_[0]);
      _unknown_fields_.Swap(&other->_unknown_fields_);
      std::swap(_cached_size_, other->_cached_size_);
    }
  }
  
  ::google::protobuf::Metadata CMsgGCUpdateSubGCSessionInfo::GetMetadata() const {
    protobuf_AssignDescriptorsOnce();
    ::google::protobuf::Metadata metadata;
    metadata.descriptor = CMsgGCUpdateSubGCSessionInfo_descriptor_;
    metadata.reflection = CMsgGCUpdateSubGCSessionInfo_reflection_;
    return metadata;
  }
  
  
  // ===================================================================
  
  #ifndef _MSC_VER
  const int CMsgGCRequestSubGCSessionInfo::kSteamidFieldNumber;
  #endif  // !_MSC_VER
  
  CMsgGCRequestSubGCSessionInfo::CMsgGCRequestSubGCSessionInfo()
    : ::google::protobuf::Message() {
    SharedCtor();
  }
  
  void CMsgGCRequestSubGCSessionInfo::InitAsDefaultInstance() {
  }
  
  CMsgGCRequestSubGCSessionInfo::CMsgGCRequestSubGCSessionInfo(const CMsgGCRequestSubGCSessionInfo& from)
    : ::google::protobuf::Message() {
    SharedCtor();
    MergeFrom(from);
  }
  
  void CMsgGCRequestSubGCSessionInfo::SharedCtor() {
    _cached_size_ = 0;
    steamid_ = GOOGLE_ULONGLONG(0);
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
  }
  
  CMsgGCRequestSubGCSessionInfo::~CMsgGCRequestSubGCSessionInfo() {
    SharedDtor();
  }
  
  void CMsgGCRequestSubGCSessionInfo::SharedDtor() {
    if (this != default_instance_) {
    }
  }
  
  void CMsgGCRequestSubGCSessionInfo::SetCachedSize(int size) const {
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
  }
  const ::google::protobuf::Descriptor* CMsgGCRequestSubGCSessionInfo::descriptor() {
    protobuf_AssignDescriptorsOnce();
    return CMsgGCRequestSubGCSessionInfo_descriptor_;
  }
  
  const CMsgGCRequestSubGCSessionInfo& CMsgGCRequestSubGCSessionInfo::default_instance() {
    if (default_instance_ == NULL) protobuf_AddDesc_gcsdk_5fgcmessages_2eproto();  return *default_instance_;
  }
  
  CMsgGCRequestSubGCSessionInfo* CMsgGCRequestSubGCSessionInfo::default_instance_ = NULL;
  
  CMsgGCRequestSubGCSessionInfo* CMsgGCRequestSubGCSessionInfo::New() const {
    return new CMsgGCRequestSubGCSessionInfo;
  }
  
  void CMsgGCRequestSubGCSessionInfo::Clear() {
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      steamid_ = GOOGLE_ULONGLONG(0);
    }
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
    mutable_unknown_fields()->Clear();
  }
  
  bool CMsgGCRequestSubGCSessionInfo::MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) {
  #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
    ::google::protobuf::uint32 tag;
    while ((tag = input->ReadTag()) != 0) {
      switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
        // optional fixed64 steamid = 1;
        case 1: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                   input, &steamid_)));
            _set_bit(0);
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectAtEnd()) return true;
          break;
        }
        
        default: {
        handle_uninterpreted:
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
            return true;
          }
          DO_(::google::protobuf::internal::WireFormat::SkipField(
                input, tag, mutable_unknown_fields()));
          break;
        }
      }
    }
    return true;
  #undef DO_
  }
  
  void CMsgGCRequestSubGCSessionInfo::SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const {
    // optional fixed64 steamid = 1;
    if (_has_bit(0)) {
      ::google::protobuf::internal::WireFormatLite::WriteFixed64(1, this->steamid(), output);
    }
    
    if (!unknown_fields().empty()) {
      ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
          unknown_fields(), output);
    }
  }
  
  ::google::protobuf::uint8* CMsgGCRequestSubGCSessionInfo::SerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const {
    // optional fixed64 steamid = 1;
    if (_has_bit(0)) {
      target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(1, this->steamid(), target);
    }
    
    if (!unknown_fields().empty()) {
      target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
          unknown_fields(), target);
    }
    return target;
  }
  
  int CMsgGCRequestSubGCSessionInfo::ByteSize() const {
    int total_size = 0;
    
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      // optional fixed64 steamid = 1;
      if (has_steamid()) {
        total_size += 1 + 8;
      }
      
    }
    if (!unknown_fields().empty()) {
      total_size +=
        ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
          unknown_fields());
    }
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = total_size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
    return total_size;
  }
  
  void CMsgGCRequestSubGCSessionInfo::MergeFrom(const ::google::protobuf::Message& from) {
    GOOGLE_CHECK_NE(&from, this);
    const CMsgGCRequestSubGCSessionInfo* source =
      ::google::protobuf::internal::dynamic_cast_if_available<const CMsgGCRequestSubGCSessionInfo*>(
        &from);
    if (source == NULL) {
      ::google::protobuf::internal::ReflectionOps::Merge(from, this);
    } else {
      MergeFrom(*source);
    }
  }
  
  void CMsgGCRequestSubGCSessionInfo::MergeFrom(const CMsgGCRequestSubGCSessionInfo& from) {
    GOOGLE_CHECK_NE(&from, this);
    if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      if (from._has_bit(0)) {
        set_steamid(from.steamid());
      }
    }
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
  
  void CMsgGCRequestSubGCSessionInfo::CopyFrom(const ::google::protobuf::Message& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void CMsgGCRequestSubGCSessionInfo::CopyFrom(const CMsgGCRequestSubGCSessionInfo& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  bool CMsgGCRequestSubGCSessionInfo::IsInitialized() const {
    
    return true;
  }
  
  void CMsgGCRequestSubGCSessionInfo::Swap(CMsgGCRequestSubGCSessionInfo* other) {
    if (other != this) {
      std::swap(steamid_, other->steamid_);
      std::swap(_has_bits_[0], other->_has_bits_[0]);
      _unknown_fields_.Swap(&other->_unknown_fields_);
      std::swap(_cached_size_, other->_cached_size_);
    }
  }
  
  ::google::protobuf::Metadata CMsgGCRequestSubGCSessionInfo::GetMetadata() const {
    protobuf_AssignDescriptorsOnce();
    ::google::protobuf::Metadata metadata;
    metadata.descriptor = CMsgGCRequestSubGCSessionInfo_descriptor_;
    metadata.reflection = CMsgGCRequestSubGCSessionInfo_reflection_;
    return metadata;
  }
  
  
  // ===================================================================
  
  #ifndef _MSC_VER
  const int CMsgGCRequestSubGCSessionInfoResponse::kIpFieldNumber;
  const int CMsgGCRequestSubGCSessionInfoResponse::kTrustedFieldNumber;
  #endif  // !_MSC_VER
  
  CMsgGCRequestSubGCSessionInfoResponse::CMsgGCRequestSubGCSessionInfoResponse()
    : ::google::protobuf::Message() {
    SharedCtor();
  }
  
  void CMsgGCRequestSubGCSessionInfoResponse::InitAsDefaultInstance() {
  }
  
  CMsgGCRequestSubGCSessionInfoResponse::CMsgGCRequestSubGCSessionInfoResponse(const CMsgGCRequestSubGCSessionInfoResponse& from)
    : ::google::protobuf::Message() {
    SharedCtor();
    MergeFrom(from);
  }
  
  void CMsgGCRequestSubGCSessionInfoResponse::SharedCtor() {
    _cached_size_ = 0;
    ip_ = 0u;
    trusted_ = false;
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
  }
  
  CMsgGCRequestSubGCSessionInfoResponse::~CMsgGCRequestSubGCSessionInfoResponse() {
    SharedDtor();
  }
  
  void CMsgGCRequestSubGCSessionInfoResponse::SharedDtor() {
    if (this != default_instance_) {
    }
  }
  
  void CMsgGCRequestSubGCSessionInfoResponse::SetCachedSize(int size) const {
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
  }
  const ::google::protobuf::Descriptor* CMsgGCRequestSubGCSessionInfoResponse::descriptor() {
    protobuf_AssignDescriptorsOnce();
    return CMsgGCRequestSubGCSessionInfoResponse_descriptor_;
  }
  
  const CMsgGCRequestSubGCSessionInfoResponse& CMsgGCRequestSubGCSessionInfoResponse::default_instance() {
    if (default_instance_ == NULL) protobuf_AddDesc_gcsdk_5fgcmessages_2eproto();  return *default_instance_;
  }
  
  CMsgGCRequestSubGCSessionInfoResponse* CMsgGCRequestSubGCSessionInfoResponse::default_instance_ = NULL;
  
  CMsgGCRequestSubGCSessionInfoResponse* CMsgGCRequestSubGCSessionInfoResponse::New() const {
    return new CMsgGCRequestSubGCSessionInfoResponse;
  }
  
  void CMsgGCRequestSubGCSessionInfoResponse::Clear() {
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      ip_ = 0u;
      trusted_ = false;
    }
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
    mutable_unknown_fields()->Clear();
  }
  
  bool CMsgGCRequestSubGCSessionInfoResponse::MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) {
  #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
    ::google::protobuf::uint32 tag;
    while ((tag = input->ReadTag()) != 0) {
      switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
        // optional fixed32 ip = 1;
        case 1: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
                   input, &ip_)));
            _set_bit(0);
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectTag(16)) goto parse_trusted;
          break;
        }
        
        // optional bool trusted = 2;
        case 2: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
           parse_trusted:
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                   input, &trusted_)));
            _set_bit(1);
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectAtEnd()) return true;
          break;
        }
        
        default: {
        handle_uninterpreted:
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
            return true;
          }
          DO_(::google::protobuf::internal::WireFormat::SkipField(
                input, tag, mutable_unknown_fields()));
          break;
        }
      }
    }
    return true;
  #undef DO_
  }
  
  void CMsgGCRequestSubGCSessionInfoResponse::SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const {
    // optional fixed32 ip = 1;
    if (_has_bit(0)) {
      ::google::protobuf::internal::WireFormatLite::WriteFixed32(1, this->ip(), output);
    }
    
    // optional bool trusted = 2;
    if (_has_bit(1)) {
      ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->trusted(), output);
    }
    
    if (!unknown_fields().empty()) {
      ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
          unknown_fields(), output);
    }
  }
  
  ::google::protobuf::uint8* CMsgGCRequestSubGCSessionInfoResponse::SerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const {
    // optional fixed32 ip = 1;
    if (_has_bit(0)) {
      target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(1, this->ip(), target);
    }
    
    // optional bool trusted = 2;
    if (_has_bit(1)) {
      target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->trusted(), target);
    }
    
    if (!unknown_fields().empty()) {
      target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
          unknown_fields(), target);
    }
    return target;
  }
  
  int CMsgGCRequestSubGCSessionInfoResponse::ByteSize() const {
    int total_size = 0;
    
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      // optional fixed32 ip = 1;
      if (has_ip()) {
        total_size += 1 + 4;
      }
      
      // optional bool trusted = 2;
      if (has_trusted()) {
        total_size += 1 + 1;
      }
      
    }
    if (!unknown_fields().empty()) {
      total_size +=
        ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
          unknown_fields());
    }
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = total_size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
    return total_size;
  }
  
  void CMsgGCRequestSubGCSessionInfoResponse::MergeFrom(const ::google::protobuf::Message& from) {
    GOOGLE_CHECK_NE(&from, this);
    const CMsgGCRequestSubGCSessionInfoResponse* source =
      ::google::protobuf::internal::dynamic_cast_if_available<const CMsgGCRequestSubGCSessionInfoResponse*>(
        &from);
    if (source == NULL) {
      ::google::protobuf::internal::ReflectionOps::Merge(from, this);
    } else {
      MergeFrom(*source);
    }
  }
  
  void CMsgGCRequestSubGCSessionInfoResponse::MergeFrom(const CMsgGCRequestSubGCSessionInfoResponse& from) {
    GOOGLE_CHECK_NE(&from, this);
    if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      if (from._has_bit(0)) {
        set_ip(from.ip());
      }
      if (from._has_bit(1)) {
        set_trusted(from.trusted());
      }
    }
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
  
  void CMsgGCRequestSubGCSessionInfoResponse::CopyFrom(const ::google::protobuf::Message& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void CMsgGCRequestSubGCSessionInfoResponse::CopyFrom(const CMsgGCRequestSubGCSessionInfoResponse& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  bool CMsgGCRequestSubGCSessionInfoResponse::IsInitialized() const {
    
    return true;
  }
  
  void CMsgGCRequestSubGCSessionInfoResponse::Swap(CMsgGCRequestSubGCSessionInfoResponse* other) {
    if (other != this) {
      std::swap(ip_, other->ip_);
      std::swap(trusted_, other->trusted_);
      std::swap(_has_bits_[0], other->_has_bits_[0]);
      _unknown_fields_.Swap(&other->_unknown_fields_);
      std::swap(_cached_size_, other->_cached_size_);
    }
  }
  
  ::google::protobuf::Metadata CMsgGCRequestSubGCSessionInfoResponse::GetMetadata() const {
    protobuf_AssignDescriptorsOnce();
    ::google::protobuf::Metadata metadata;
    metadata.descriptor = CMsgGCRequestSubGCSessionInfoResponse_descriptor_;
    metadata.reflection = CMsgGCRequestSubGCSessionInfoResponse_reflection_;
    return metadata;
  }
  
  
  // ===================================================================
  
  #ifndef _MSC_VER
  const int CMsgGCToGCIncrementRecruitmentLevel::kSteamidFieldNumber;
  #endif  // !_MSC_VER
  
  CMsgGCToGCIncrementRecruitmentLevel::CMsgGCToGCIncrementRecruitmentLevel()
    : ::google::protobuf::Message() {
    SharedCtor();
  }
  
  void CMsgGCToGCIncrementRecruitmentLevel::InitAsDefaultInstance() {
  }
  
  CMsgGCToGCIncrementRecruitmentLevel::CMsgGCToGCIncrementRecruitmentLevel(const CMsgGCToGCIncrementRecruitmentLevel& from)
    : ::google::protobuf::Message() {
    SharedCtor();
    MergeFrom(from);
  }
  
  void CMsgGCToGCIncrementRecruitmentLevel::SharedCtor() {
    _cached_size_ = 0;
    steamid_ = GOOGLE_ULONGLONG(0);
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
  }
  
  CMsgGCToGCIncrementRecruitmentLevel::~CMsgGCToGCIncrementRecruitmentLevel() {
    SharedDtor();
  }
  
  void CMsgGCToGCIncrementRecruitmentLevel::SharedDtor() {
    if (this != default_instance_) {
    }
  }
  
  void CMsgGCToGCIncrementRecruitmentLevel::SetCachedSize(int size) const {
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
  }
  const ::google::protobuf::Descriptor* CMsgGCToGCIncrementRecruitmentLevel::descriptor() {
    protobuf_AssignDescriptorsOnce();
    return CMsgGCToGCIncrementRecruitmentLevel_descriptor_;
  }
  
  const CMsgGCToGCIncrementRecruitmentLevel& CMsgGCToGCIncrementRecruitmentLevel::default_instance() {
    if (default_instance_ == NULL) protobuf_AddDesc_gcsdk_5fgcmessages_2eproto();  return *default_instance_;
  }
  
  CMsgGCToGCIncrementRecruitmentLevel* CMsgGCToGCIncrementRecruitmentLevel::default_instance_ = NULL;
  
  CMsgGCToGCIncrementRecruitmentLevel* CMsgGCToGCIncrementRecruitmentLevel::New() const {
    return new CMsgGCToGCIncrementRecruitmentLevel;
  }
  
  void CMsgGCToGCIncrementRecruitmentLevel::Clear() {
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      steamid_ = GOOGLE_ULONGLONG(0);
    }
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
    mutable_unknown_fields()->Clear();
  }
  
  bool CMsgGCToGCIncrementRecruitmentLevel::MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) {
  #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
    ::google::protobuf::uint32 tag;
    while ((tag = input->ReadTag()) != 0) {
      switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
        // optional fixed64 steamid = 1;
        case 1: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                   input, &steamid_)));
            _set_bit(0);
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectAtEnd()) return true;
          break;
        }
        
        default: {
        handle_uninterpreted:
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
            return true;
          }
          DO_(::google::protobuf::internal::WireFormat::SkipField(
                input, tag, mutable_unknown_fields()));
          break;
        }
      }
    }
    return true;
  #undef DO_
  }
  
  void CMsgGCToGCIncrementRecruitmentLevel::SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const {
    // optional fixed64 steamid = 1;
    if (_has_bit(0)) {
      ::google::protobuf::internal::WireFormatLite::WriteFixed64(1, this->steamid(), output);
    }
    
    if (!unknown_fields().empty()) {
      ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
          unknown_fields(), output);
    }
  }
  
  ::google::protobuf::uint8* CMsgGCToGCIncrementRecruitmentLevel::SerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const {
    // optional fixed64 steamid = 1;
    if (_has_bit(0)) {
      target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(1, this->steamid(), target);
    }
    
    if (!unknown_fields().empty()) {
      target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
          unknown_fields(), target);
    }
    return target;
  }
  
  int CMsgGCToGCIncrementRecruitmentLevel::ByteSize() const {
    int total_size = 0;
    
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      // optional fixed64 steamid = 1;
      if (has_steamid()) {
        total_size += 1 + 8;
      }
      
    }
    if (!unknown_fields().empty()) {
      total_size +=
        ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
          unknown_fields());
    }
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = total_size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
    return total_size;
  }
  
  void CMsgGCToGCIncrementRecruitmentLevel::MergeFrom(const ::google::protobuf::Message& from) {
    GOOGLE_CHECK_NE(&from, this);
    const CMsgGCToGCIncrementRecruitmentLevel* source =
      ::google::protobuf::internal::dynamic_cast_if_available<const CMsgGCToGCIncrementRecruitmentLevel*>(
        &from);
    if (source == NULL) {
      ::google::protobuf::internal::ReflectionOps::Merge(from, this);
    } else {
      MergeFrom(*source);
    }
  }
  
  void CMsgGCToGCIncrementRecruitmentLevel::MergeFrom(const CMsgGCToGCIncrementRecruitmentLevel& from) {
    GOOGLE_CHECK_NE(&from, this);
    if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      if (from._has_bit(0)) {
        set_steamid(from.steamid());
      }
    }
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
  
  void CMsgGCToGCIncrementRecruitmentLevel::CopyFrom(const ::google::protobuf::Message& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void CMsgGCToGCIncrementRecruitmentLevel::CopyFrom(const CMsgGCToGCIncrementRecruitmentLevel& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  bool CMsgGCToGCIncrementRecruitmentLevel::IsInitialized() const {
    
    return true;
  }
  
  void CMsgGCToGCIncrementRecruitmentLevel::Swap(CMsgGCToGCIncrementRecruitmentLevel* other) {
    if (other != this) {
      std::swap(steamid_, other->steamid_);
      std::swap(_has_bits_[0], other->_has_bits_[0]);
      _unknown_fields_.Swap(&other->_unknown_fields_);
      std::swap(_cached_size_, other->_cached_size_);
    }
  }
  
  ::google::protobuf::Metadata CMsgGCToGCIncrementRecruitmentLevel::GetMetadata() const {
    protobuf_AssignDescriptorsOnce();
    ::google::protobuf::Metadata metadata;
    metadata.descriptor = CMsgGCToGCIncrementRecruitmentLevel_descriptor_;
    metadata.reflection = CMsgGCToGCIncrementRecruitmentLevel_reflection_;
    return metadata;
  }
  
  
  // ===================================================================
  
  #ifndef _MSC_VER
  const int CMsgSOCacheHaveVersion::kSoidFieldNumber;
  const int CMsgSOCacheHaveVersion::kVersionFieldNumber;
  const int CMsgSOCacheHaveVersion::kServiceIdFieldNumber;
  #endif  // !_MSC_VER
  
  CMsgSOCacheHaveVersion::CMsgSOCacheHaveVersion()
    : ::google::protobuf::Message() {
    SharedCtor();
  }
  
  void CMsgSOCacheHaveVersion::InitAsDefaultInstance() {
    soid_ = const_cast< ::CMsgSOIDOwner*>(&::CMsgSOIDOwner::default_instance());
  }
  
  CMsgSOCacheHaveVersion::CMsgSOCacheHaveVersion(const CMsgSOCacheHaveVersion& from)
    : ::google::protobuf::Message() {
    SharedCtor();
    MergeFrom(from);
  }
  
  void CMsgSOCacheHaveVersion::SharedCtor() {
    _cached_size_ = 0;
    soid_ = NULL;
    version_ = GOOGLE_ULONGLONG(0);
    service_id_ = 0u;
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
  }
  
  CMsgSOCacheHaveVersion::~CMsgSOCacheHaveVersion() {
    SharedDtor();
  }
  
  void CMsgSOCacheHaveVersion::SharedDtor() {
    if (this != default_instance_) {
      delete soid_;
    }
  }
  
  void CMsgSOCacheHaveVersion::SetCachedSize(int size) const {
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
  }
  const ::google::protobuf::Descriptor* CMsgSOCacheHaveVersion::descriptor() {
    protobuf_AssignDescriptorsOnce();
    return CMsgSOCacheHaveVersion_descriptor_;
  }
  
  const CMsgSOCacheHaveVersion& CMsgSOCacheHaveVersion::default_instance() {
    if (default_instance_ == NULL) protobuf_AddDesc_gcsdk_5fgcmessages_2eproto();  return *default_instance_;
  }
  
  CMsgSOCacheHaveVersion* CMsgSOCacheHaveVersion::default_instance_ = NULL;
  
  CMsgSOCacheHaveVersion* CMsgSOCacheHaveVersion::New() const {
    return new CMsgSOCacheHaveVersion;
  }
  
  void CMsgSOCacheHaveVersion::Clear() {
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      if (_has_bit(0)) {
        if (soid_ != NULL) soid_->::CMsgSOIDOwner::Clear();
      }
      version_ = GOOGLE_ULONGLONG(0);
      service_id_ = 0u;
    }
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
    mutable_unknown_fields()->Clear();
  }
  
  bool CMsgSOCacheHaveVersion::MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) {
  #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
    ::google::protobuf::uint32 tag;
    while ((tag = input->ReadTag()) != 0) {
      switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
        // optional .CMsgSOIDOwner soid = 1;
        case 1: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
            DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                 input, mutable_soid()));
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectTag(17)) goto parse_version;
          break;
        }
        
        // optional fixed64 version = 2;
        case 2: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
           parse_version:
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                   input, &version_)));
            _set_bit(1);
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectTag(24)) goto parse_service_id;
          break;
        }
        
        // optional uint32 service_id = 3;
        case 3: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
           parse_service_id:
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                   input, &service_id_)));
            _set_bit(2);
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectAtEnd()) return true;
          break;
        }
        
        default: {
        handle_uninterpreted:
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
            return true;
          }
          DO_(::google::protobuf::internal::WireFormat::SkipField(
                input, tag, mutable_unknown_fields()));
          break;
        }
      }
    }
    return true;
  #undef DO_
  }
  
  void CMsgSOCacheHaveVersion::SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const {
    // optional .CMsgSOIDOwner soid = 1;
    if (_has_bit(0)) {
      ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
        1, this->soid(), output);
    }
    
    // optional fixed64 version = 2;
    if (_has_bit(1)) {
      ::google::protobuf::internal::WireFormatLite::WriteFixed64(2, this->version(), output);
    }
    
    // optional uint32 service_id = 3;
    if (_has_bit(2)) {
      ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->service_id(), output);
    }
    
    if (!unknown_fields().empty()) {
      ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
          unknown_fields(), output);
    }
  }
  
  ::google::protobuf::uint8* CMsgSOCacheHaveVersion::SerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const {
    // optional .CMsgSOIDOwner soid = 1;
    if (_has_bit(0)) {
      target = ::google::protobuf::internal::WireFormatLite::
        WriteMessageNoVirtualToArray(
          1, this->soid(), target);
    }
    
    // optional fixed64 version = 2;
    if (_has_bit(1)) {
      target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(2, this->version(), target);
    }
    
    // optional uint32 service_id = 3;
    if (_has_bit(2)) {
      target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->service_id(), target);
    }
    
    if (!unknown_fields().empty()) {
      target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
          unknown_fields(), target);
    }
    return target;
  }
  
  int CMsgSOCacheHaveVersion::ByteSize() const {
    int total_size = 0;
    
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      // optional .CMsgSOIDOwner soid = 1;
      if (has_soid()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
            this->soid());
      }
      
      // optional fixed64 version = 2;
      if (has_version()) {
        total_size += 1 + 8;
      }
      
      // optional uint32 service_id = 3;
      if (has_service_id()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormatLite::UInt32Size(
            this->service_id());
      }
      
    }
    if (!unknown_fields().empty()) {
      total_size +=
        ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
          unknown_fields());
    }
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = total_size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
    return total_size;
  }
  
  void CMsgSOCacheHaveVersion::MergeFrom(const ::google::protobuf::Message& from) {
    GOOGLE_CHECK_NE(&from, this);
    const CMsgSOCacheHaveVersion* source =
      ::google::protobuf::internal::dynamic_cast_if_available<const CMsgSOCacheHaveVersion*>(
        &from);
    if (source == NULL) {
      ::google::protobuf::internal::ReflectionOps::Merge(from, this);
    } else {
      MergeFrom(*source);
    }
  }
  
  void CMsgSOCacheHaveVersion::MergeFrom(const CMsgSOCacheHaveVersion& from) {
    GOOGLE_CHECK_NE(&from, this);
    if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      if (from._has_bit(0)) {
        mutable_soid()->::CMsgSOIDOwner::MergeFrom(from.soid());
      }
      if (from._has_bit(1)) {
        set_version(from.version());
      }
      if (from._has_bit(2)) {
        set_service_id(from.service_id());
      }
    }
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
  
  void CMsgSOCacheHaveVersion::CopyFrom(const ::google::protobuf::Message& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void CMsgSOCacheHaveVersion::CopyFrom(const CMsgSOCacheHaveVersion& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  bool CMsgSOCacheHaveVersion::IsInitialized() const {
    
    return true;
  }
  
  void CMsgSOCacheHaveVersion::Swap(CMsgSOCacheHaveVersion* other) {
    if (other != this) {
      std::swap(soid_, other->soid_);
      std::swap(version_, other->version_);
      std::swap(service_id_, other->service_id_);
      std::swap(_has_bits_[0], other->_has_bits_[0]);
      _unknown_fields_.Swap(&other->_unknown_fields_);
      std::swap(_cached_size_, other->_cached_size_);
    }
  }
  
  ::google::protobuf::Metadata CMsgSOCacheHaveVersion::GetMetadata() const {
    protobuf_AssignDescriptorsOnce();
    ::google::protobuf::Metadata metadata;
    metadata.descriptor = CMsgSOCacheHaveVersion_descriptor_;
    metadata.reflection = CMsgSOCacheHaveVersion_reflection_;
    return metadata;
  }
  
  
  // ===================================================================
  
  #ifndef _MSC_VER
  const int CMsgConnectionStatus::kStatusFieldNumber;
  const int CMsgConnectionStatus::kClientSessionNeedFieldNumber;
  const int CMsgConnectionStatus::kQueuePositionFieldNumber;
  const int CMsgConnectionStatus::kQueueSizeFieldNumber;
  const int CMsgConnectionStatus::kWaitSecondsFieldNumber;
  const int CMsgConnectionStatus::kEstimatedWaitSecondsRemainingFieldNumber;
  #endif  // !_MSC_VER
  
  CMsgConnectionStatus::CMsgConnectionStatus()
    : ::google::protobuf::Message() {
    SharedCtor();
  }
  
  void CMsgConnectionStatus::InitAsDefaultInstance() {
  }
  
  CMsgConnectionStatus::CMsgConnectionStatus(const CMsgConnectionStatus& from)
    : ::google::protobuf::Message() {
    SharedCtor();
    MergeFrom(from);
  }
  
  void CMsgConnectionStatus::SharedCtor() {
    _cached_size_ = 0;
    status_ = 0;
    client_session_need_ = 0u;
    queue_position_ = 0;
    queue_size_ = 0;
    wait_seconds_ = 0;
    estimated_wait_seconds_remaining_ = 0;
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
  }
  
  CMsgConnectionStatus::~CMsgConnectionStatus() {
    SharedDtor();
  }
  
  void CMsgConnectionStatus::SharedDtor() {
    if (this != default_instance_) {
    }
  }
  
  void CMsgConnectionStatus::SetCachedSize(int size) const {
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
  }
  const ::google::protobuf::Descriptor* CMsgConnectionStatus::descriptor() {
    protobuf_AssignDescriptorsOnce();
    return CMsgConnectionStatus_descriptor_;
  }
  
  const CMsgConnectionStatus& CMsgConnectionStatus::default_instance() {
    if (default_instance_ == NULL) protobuf_AddDesc_gcsdk_5fgcmessages_2eproto();  return *default_instance_;
  }
  
  CMsgConnectionStatus* CMsgConnectionStatus::default_instance_ = NULL;
  
  CMsgConnectionStatus* CMsgConnectionStatus::New() const {
    return new CMsgConnectionStatus;
  }
  
  void CMsgConnectionStatus::Clear() {
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      status_ = 0;
      client_session_need_ = 0u;
      queue_position_ = 0;
      queue_size_ = 0;
      wait_seconds_ = 0;
      estimated_wait_seconds_remaining_ = 0;
    }
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
    mutable_unknown_fields()->Clear();
  }
  
  bool CMsgConnectionStatus::MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) {
  #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
    ::google::protobuf::uint32 tag;
    while ((tag = input->ReadTag()) != 0) {
      switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
        // optional .GCConnectionStatus status = 1 [default = GCConnectionStatus_HAVE_SESSION];
        case 1: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
            int value;
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                   input, &value)));
            if (GCConnectionStatus_IsValid(value)) {
              set_status(static_cast< GCConnectionStatus >(value));
            } else {
              mutable_unknown_fields()->AddVarint(1, value);
            }
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectTag(16)) goto parse_client_session_need;
          break;
        }
        
        // optional uint32 client_session_need = 2;
        case 2: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
           parse_client_session_need:
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                   input, &client_session_need_)));
            _set_bit(1);
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectTag(24)) goto parse_queue_position;
          break;
        }
        
        // optional int32 queue_position = 3;
        case 3: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
           parse_queue_position:
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                   input, &queue_position_)));
            _set_bit(2);
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectTag(32)) goto parse_queue_size;
          break;
        }
        
        // optional int32 queue_size = 4;
        case 4: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
           parse_queue_size:
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                   input, &queue_size_)));
            _set_bit(3);
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectTag(40)) goto parse_wait_seconds;
          break;
        }
        
        // optional int32 wait_seconds = 5;
        case 5: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
           parse_wait_seconds:
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                   input, &wait_seconds_)));
            _set_bit(4);
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectTag(48)) goto parse_estimated_wait_seconds_remaining;
          break;
        }
        
        // optional int32 estimated_wait_seconds_remaining = 6;
        case 6: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
           parse_estimated_wait_seconds_remaining:
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                   input, &estimated_wait_seconds_remaining_)));
            _set_bit(5);
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectAtEnd()) return true;
          break;
        }
        
        default: {
        handle_uninterpreted:
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
            return true;
          }
          DO_(::google::protobuf::internal::WireFormat::SkipField(
                input, tag, mutable_unknown_fields()));
          break;
        }
      }
    }
    return true;
  #undef DO_
  }
  
  void CMsgConnectionStatus::SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const {
    // optional .GCConnectionStatus status = 1 [default = GCConnectionStatus_HAVE_SESSION];
    if (_has_bit(0)) {
      ::google::protobuf::internal::WireFormatLite::WriteEnum(
        1, this->status(), output);
    }
    
    // optional uint32 client_session_need = 2;
    if (_has_bit(1)) {
      ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->client_session_need(), output);
    }
    
    // optional int32 queue_position = 3;
    if (_has_bit(2)) {
      ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->queue_position(), output);
    }
    
    // optional int32 queue_size = 4;
    if (_has_bit(3)) {
      ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->queue_size(), output);
    }
    
    // optional int32 wait_seconds = 5;
    if (_has_bit(4)) {
      ::google::protobuf::internal::WireFormatLite::WriteInt32(5, this->wait_seconds(), output);
    }
    
    // optional int32 estimated_wait_seconds_remaining = 6;
    if (_has_bit(5)) {
      ::google::protobuf::internal::WireFormatLite::WriteInt32(6, this->estimated_wait_seconds_remaining(), output);
    }
    
    if (!unknown_fields().empty()) {
      ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
          unknown_fields(), output);
    }
  }
  
  ::google::protobuf::uint8* CMsgConnectionStatus::SerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const {
    // optional .GCConnectionStatus status = 1 [default = GCConnectionStatus_HAVE_SESSION];
    if (_has_bit(0)) {
      target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
        1, this->status(), target);
    }
    
    // optional uint32 client_session_need = 2;
    if (_has_bit(1)) {
      target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->client_session_need(), target);
    }
    
    // optional int32 queue_position = 3;
    if (_has_bit(2)) {
      target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->queue_position(), target);
    }
    
    // optional int32 queue_size = 4;
    if (_has_bit(3)) {
      target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(4, this->queue_size(), target);
    }
    
    // optional int32 wait_seconds = 5;
    if (_has_bit(4)) {
      target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(5, this->wait_seconds(), target);
    }
    
    // optional int32 estimated_wait_seconds_remaining = 6;
    if (_has_bit(5)) {
      target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(6, this->estimated_wait_seconds_remaining(), target);
    }
    
    if (!unknown_fields().empty()) {
      target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
          unknown_fields(), target);
    }
    return target;
  }
  
  int CMsgConnectionStatus::ByteSize() const {
    int total_size = 0;
    
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      // optional .GCConnectionStatus status = 1 [default = GCConnectionStatus_HAVE_SESSION];
      if (has_status()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormatLite::EnumSize(this->status());
      }
      
      // optional uint32 client_session_need = 2;
      if (has_client_session_need()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormatLite::UInt32Size(
            this->client_session_need());
      }
      
      // optional int32 queue_position = 3;
      if (has_queue_position()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormatLite::Int32Size(
            this->queue_position());
      }
      
      // optional int32 queue_size = 4;
      if (has_queue_size()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormatLite::Int32Size(
            this->queue_size());
      }
      
      // optional int32 wait_seconds = 5;
      if (has_wait_seconds()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormatLite::Int32Size(
            this->wait_seconds());
      }
      
      // optional int32 estimated_wait_seconds_remaining = 6;
      if (has_estimated_wait_seconds_remaining()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormatLite::Int32Size(
            this->estimated_wait_seconds_remaining());
      }
      
    }
    if (!unknown_fields().empty()) {
      total_size +=
        ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
          unknown_fields());
    }
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = total_size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
    return total_size;
  }
  
  void CMsgConnectionStatus::MergeFrom(const ::google::protobuf::Message& from) {
    GOOGLE_CHECK_NE(&from, this);
    const CMsgConnectionStatus* source =
      ::google::protobuf::internal::dynamic_cast_if_available<const CMsgConnectionStatus*>(
        &from);
    if (source == NULL) {
      ::google::protobuf::internal::ReflectionOps::Merge(from, this);
    } else {
      MergeFrom(*source);
    }
  }
  
  void CMsgConnectionStatus::MergeFrom(const CMsgConnectionStatus& from) {
    GOOGLE_CHECK_NE(&from, this);
    if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      if (from._has_bit(0)) {
        set_status(from.status());
      }
      if (from._has_bit(1)) {
        set_client_session_need(from.client_session_need());
      }
      if (from._has_bit(2)) {
        set_queue_position(from.queue_position());
      }
      if (from._has_bit(3)) {
        set_queue_size(from.queue_size());
      }
      if (from._has_bit(4)) {
        set_wait_seconds(from.wait_seconds());
      }
      if (from._has_bit(5)) {
        set_estimated_wait_seconds_remaining(from.estimated_wait_seconds_remaining());
      }
    }
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
  
  void CMsgConnectionStatus::CopyFrom(const ::google::protobuf::Message& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void CMsgConnectionStatus::CopyFrom(const CMsgConnectionStatus& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  bool CMsgConnectionStatus::IsInitialized() const {
    
    return true;
  }
  
  void CMsgConnectionStatus::Swap(CMsgConnectionStatus* other) {
    if (other != this) {
      std::swap(status_, other->status_);
      std::swap(client_session_need_, other->client_session_need_);
      std::swap(queue_position_, other->queue_position_);
      std::swap(queue_size_, other->queue_size_);
      std::swap(wait_seconds_, other->wait_seconds_);
      std::swap(estimated_wait_seconds_remaining_, other->estimated_wait_seconds_remaining_);
      std::swap(_has_bits_[0], other->_has_bits_[0]);
      _unknown_fields_.Swap(&other->_unknown_fields_);
      std::swap(_cached_size_, other->_cached_size_);
    }
  }
  
  ::google::protobuf::Metadata CMsgConnectionStatus::GetMetadata() const {
    protobuf_AssignDescriptorsOnce();
    ::google::protobuf::Metadata metadata;
    metadata.descriptor = CMsgConnectionStatus_descriptor_;
    metadata.reflection = CMsgConnectionStatus_reflection_;
    return metadata;
  }
  
  
  // ===================================================================
  
  #ifndef _MSC_VER
  const int CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions::kServiceIdFieldNumber;
  const int CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions::kVersionFieldNumber;
  #endif  // !_MSC_VER
  
  CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions::CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions()
    : ::google::protobuf::Message() {
    SharedCtor();
  }
  
  void CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions::InitAsDefaultInstance() {
  }
  
  CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions::CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions(const CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions& from)
    : ::google::protobuf::Message() {
    SharedCtor();
    MergeFrom(from);
  }
  
  void CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions::SharedCtor() {
    _cached_size_ = 0;
    service_id_ = 0u;
    version_ = GOOGLE_ULONGLONG(0);
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
  }
  
  CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions::~CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions() {
    SharedDtor();
  }
  
  void CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions::SharedDtor() {
    if (this != default_instance_) {
    }
  }
  
  void CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions::SetCachedSize(int size) const {
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
  }
  const ::google::protobuf::Descriptor* CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions::descriptor() {
    protobuf_AssignDescriptorsOnce();
    return CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions_descriptor_;
  }
  
  const CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions& CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions::default_instance() {
    if (default_instance_ == NULL) protobuf_AddDesc_gcsdk_5fgcmessages_2eproto();  return *default_instance_;
  }
  
  CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions* CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions::default_instance_ = NULL;
  
  CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions* CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions::New() const {
    return new CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions;
  }
  
  void CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions::Clear() {
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      service_id_ = 0u;
      version_ = GOOGLE_ULONGLONG(0);
    }
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
    mutable_unknown_fields()->Clear();
  }
  
  bool CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions::MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) {
  #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
    ::google::protobuf::uint32 tag;
    while ((tag = input->ReadTag()) != 0) {
      switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
        // optional uint32 service_id = 1;
        case 1: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                   input, &service_id_)));
            _set_bit(0);
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectTag(16)) goto parse_version;
          break;
        }
        
        // optional uint64 version = 2;
        case 2: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
           parse_version:
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
                   input, &version_)));
            _set_bit(1);
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectAtEnd()) return true;
          break;
        }
        
        default: {
        handle_uninterpreted:
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
            return true;
          }
          DO_(::google::protobuf::internal::WireFormat::SkipField(
                input, tag, mutable_unknown_fields()));
          break;
        }
      }
    }
    return true;
  #undef DO_
  }
  
  void CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions::SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const {
    // optional uint32 service_id = 1;
    if (_has_bit(0)) {
      ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->service_id(), output);
    }
    
    // optional uint64 version = 2;
    if (_has_bit(1)) {
      ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->version(), output);
    }
    
    if (!unknown_fields().empty()) {
      ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
          unknown_fields(), output);
    }
  }
  
  ::google::protobuf::uint8* CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions::SerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const {
    // optional uint32 service_id = 1;
    if (_has_bit(0)) {
      target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->service_id(), target);
    }
    
    // optional uint64 version = 2;
    if (_has_bit(1)) {
      target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->version(), target);
    }
    
    if (!unknown_fields().empty()) {
      target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
          unknown_fields(), target);
    }
    return target;
  }
  
  int CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions::ByteSize() const {
    int total_size = 0;
    
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      // optional uint32 service_id = 1;
      if (has_service_id()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormatLite::UInt32Size(
            this->service_id());
      }
      
      // optional uint64 version = 2;
      if (has_version()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormatLite::UInt64Size(
            this->version());
      }
      
    }
    if (!unknown_fields().empty()) {
      total_size +=
        ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
          unknown_fields());
    }
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = total_size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
    return total_size;
  }
  
  void CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions::MergeFrom(const ::google::protobuf::Message& from) {
    GOOGLE_CHECK_NE(&from, this);
    const CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions* source =
      ::google::protobuf::internal::dynamic_cast_if_available<const CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions*>(
        &from);
    if (source == NULL) {
      ::google::protobuf::internal::ReflectionOps::Merge(from, this);
    } else {
      MergeFrom(*source);
    }
  }
  
  void CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions::MergeFrom(const CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions& from) {
    GOOGLE_CHECK_NE(&from, this);
    if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      if (from._has_bit(0)) {
        set_service_id(from.service_id());
      }
      if (from._has_bit(1)) {
        set_version(from.version());
      }
    }
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
  
  void CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions::CopyFrom(const ::google::protobuf::Message& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions::CopyFrom(const CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  bool CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions::IsInitialized() const {
    
    return true;
  }
  
  void CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions::Swap(CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions* other) {
    if (other != this) {
      std::swap(service_id_, other->service_id_);
      std::swap(version_, other->version_);
      std::swap(_has_bits_[0], other->_has_bits_[0]);
      _unknown_fields_.Swap(&other->_unknown_fields_);
      std::swap(_cached_size_, other->_cached_size_);
    }
  }
  
  ::google::protobuf::Metadata CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions::GetMetadata() const {
    protobuf_AssignDescriptorsOnce();
    ::google::protobuf::Metadata metadata;
    metadata.descriptor = CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions_descriptor_;
    metadata.reflection = CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions_reflection_;
    return metadata;
  }
  
  
  // -------------------------------------------------------------------
  
  #ifndef _MSC_VER
  const int CMsgGCToGCSOCacheSubscribe::kSubscriberFieldNumber;
  const int CMsgGCToGCSOCacheSubscribe::kSubscribeToFieldNumber;
  const int CMsgGCToGCSOCacheSubscribe::kSyncVersionFieldNumber;
  const int CMsgGCToGCSOCacheSubscribe::kHaveVersionsFieldNumber;
  #endif  // !_MSC_VER
  
  CMsgGCToGCSOCacheSubscribe::CMsgGCToGCSOCacheSubscribe()
    : ::google::protobuf::Message() {
    SharedCtor();
  }
  
  void CMsgGCToGCSOCacheSubscribe::InitAsDefaultInstance() {
  }
  
  CMsgGCToGCSOCacheSubscribe::CMsgGCToGCSOCacheSubscribe(const CMsgGCToGCSOCacheSubscribe& from)
    : ::google::protobuf::Message() {
    SharedCtor();
    MergeFrom(from);
  }
  
  void CMsgGCToGCSOCacheSubscribe::SharedCtor() {
    _cached_size_ = 0;
    subscriber_ = GOOGLE_ULONGLONG(0);
    subscribe_to_ = GOOGLE_ULONGLONG(0);
    sync_version_ = GOOGLE_ULONGLONG(0);
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
  }
  
  CMsgGCToGCSOCacheSubscribe::~CMsgGCToGCSOCacheSubscribe() {
    SharedDtor();
  }
  
  void CMsgGCToGCSOCacheSubscribe::SharedDtor() {
    if (this != default_instance_) {
    }
  }
  
  void CMsgGCToGCSOCacheSubscribe::SetCachedSize(int size) const {
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
  }
  const ::google::protobuf::Descriptor* CMsgGCToGCSOCacheSubscribe::descriptor() {
    protobuf_AssignDescriptorsOnce();
    return CMsgGCToGCSOCacheSubscribe_descriptor_;
  }
  
  const CMsgGCToGCSOCacheSubscribe& CMsgGCToGCSOCacheSubscribe::default_instance() {
    if (default_instance_ == NULL) protobuf_AddDesc_gcsdk_5fgcmessages_2eproto();  return *default_instance_;
  }
  
  CMsgGCToGCSOCacheSubscribe* CMsgGCToGCSOCacheSubscribe::default_instance_ = NULL;
  
  CMsgGCToGCSOCacheSubscribe* CMsgGCToGCSOCacheSubscribe::New() const {
    return new CMsgGCToGCSOCacheSubscribe;
  }
  
  void CMsgGCToGCSOCacheSubscribe::Clear() {
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      subscriber_ = GOOGLE_ULONGLONG(0);
      subscribe_to_ = GOOGLE_ULONGLONG(0);
      sync_version_ = GOOGLE_ULONGLONG(0);
    }
    have_versions_.Clear();
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
    mutable_unknown_fields()->Clear();
  }
  
  bool CMsgGCToGCSOCacheSubscribe::MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) {
  #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
    ::google::protobuf::uint32 tag;
    while ((tag = input->ReadTag()) != 0) {
      switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
        // optional fixed64 subscriber = 1;
        case 1: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                   input, &subscriber_)));
            _set_bit(0);
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectTag(17)) goto parse_subscribe_to;
          break;
        }
        
        // optional fixed64 subscribe_to = 2;
        case 2: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
           parse_subscribe_to:
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                   input, &subscribe_to_)));
            _set_bit(1);
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectTag(25)) goto parse_sync_version;
          break;
        }
        
        // optional fixed64 sync_version = 3;
        case 3: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
           parse_sync_version:
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                   input, &sync_version_)));
            _set_bit(2);
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectTag(34)) goto parse_have_versions;
          break;
        }
        
        // repeated .CMsgGCToGCSOCacheSubscribe.CMsgHaveVersions have_versions = 4;
        case 4: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
           parse_have_versions:
            DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                  input, add_have_versions()));
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectTag(34)) goto parse_have_versions;
          if (input->ExpectAtEnd()) return true;
          break;
        }
        
        default: {
        handle_uninterpreted:
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
            return true;
          }
          DO_(::google::protobuf::internal::WireFormat::SkipField(
                input, tag, mutable_unknown_fields()));
          break;
        }
      }
    }
    return true;
  #undef DO_
  }
  
  void CMsgGCToGCSOCacheSubscribe::SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const {
    // optional fixed64 subscriber = 1;
    if (_has_bit(0)) {
      ::google::protobuf::internal::WireFormatLite::WriteFixed64(1, this->subscriber(), output);
    }
    
    // optional fixed64 subscribe_to = 2;
    if (_has_bit(1)) {
      ::google::protobuf::internal::WireFormatLite::WriteFixed64(2, this->subscribe_to(), output);
    }
    
    // optional fixed64 sync_version = 3;
    if (_has_bit(2)) {
      ::google::protobuf::internal::WireFormatLite::WriteFixed64(3, this->sync_version(), output);
    }
    
    // repeated .CMsgGCToGCSOCacheSubscribe.CMsgHaveVersions have_versions = 4;
    for (int i = 0; i < this->have_versions_size(); i++) {
      ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
        4, this->have_versions(i), output);
    }
    
    if (!unknown_fields().empty()) {
      ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
          unknown_fields(), output);
    }
  }
  
  ::google::protobuf::uint8* CMsgGCToGCSOCacheSubscribe::SerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const {
    // optional fixed64 subscriber = 1;
    if (_has_bit(0)) {
      target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(1, this->subscriber(), target);
    }
    
    // optional fixed64 subscribe_to = 2;
    if (_has_bit(1)) {
      target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(2, this->subscribe_to(), target);
    }
    
    // optional fixed64 sync_version = 3;
    if (_has_bit(2)) {
      target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(3, this->sync_version(), target);
    }
    
    // repeated .CMsgGCToGCSOCacheSubscribe.CMsgHaveVersions have_versions = 4;
    for (int i = 0; i < this->have_versions_size(); i++) {
      target = ::google::protobuf::internal::WireFormatLite::
        WriteMessageNoVirtualToArray(
          4, this->have_versions(i), target);
    }
    
    if (!unknown_fields().empty()) {
      target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
          unknown_fields(), target);
    }
    return target;
  }
  
  int CMsgGCToGCSOCacheSubscribe::ByteSize() const {
    int total_size = 0;
    
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      // optional fixed64 subscriber = 1;
      if (has_subscriber()) {
        total_size += 1 + 8;
      }
      
      // optional fixed64 subscribe_to = 2;
      if (has_subscribe_to()) {
        total_size += 1 + 8;
      }
      
      // optional fixed64 sync_version = 3;
      if (has_sync_version()) {
        total_size += 1 + 8;
      }
      
    }
    // repeated .CMsgGCToGCSOCacheSubscribe.CMsgHaveVersions have_versions = 4;
    total_size += 1 * this->have_versions_size();
    for (int i = 0; i < this->have_versions_size(); i++) {
      total_size +=
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->have_versions(i));
    }
    
    if (!unknown_fields().empty()) {
      total_size +=
        ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
          unknown_fields());
    }
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = total_size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
    return total_size;
  }
  
  void CMsgGCToGCSOCacheSubscribe::MergeFrom(const ::google::protobuf::Message& from) {
    GOOGLE_CHECK_NE(&from, this);
    const CMsgGCToGCSOCacheSubscribe* source =
      ::google::protobuf::internal::dynamic_cast_if_available<const CMsgGCToGCSOCacheSubscribe*>(
        &from);
    if (source == NULL) {
      ::google::protobuf::internal::ReflectionOps::Merge(from, this);
    } else {
      MergeFrom(*source);
    }
  }
  
  void CMsgGCToGCSOCacheSubscribe::MergeFrom(const CMsgGCToGCSOCacheSubscribe& from) {
    GOOGLE_CHECK_NE(&from, this);
    have_versions_.MergeFrom(from.have_versions_);
    if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      if (from._has_bit(0)) {
        set_subscriber(from.subscriber());
      }
      if (from._has_bit(1)) {
        set_subscribe_to(from.subscribe_to());
      }
      if (from._has_bit(2)) {
        set_sync_version(from.sync_version());
      }
    }
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
  
  void CMsgGCToGCSOCacheSubscribe::CopyFrom(const ::google::protobuf::Message& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void CMsgGCToGCSOCacheSubscribe::CopyFrom(const CMsgGCToGCSOCacheSubscribe& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  bool CMsgGCToGCSOCacheSubscribe::IsInitialized() const {
    
    return true;
  }
  
  void CMsgGCToGCSOCacheSubscribe::Swap(CMsgGCToGCSOCacheSubscribe* other) {
    if (other != this) {
      std::swap(subscriber_, other->subscriber_);
      std::swap(subscribe_to_, other->subscribe_to_);
      std::swap(sync_version_, other->sync_version_);
      have_versions_.Swap(&other->have_versions_);
      std::swap(_has_bits_[0], other->_has_bits_[0]);
      _unknown_fields_.Swap(&other->_unknown_fields_);
      std::swap(_cached_size_, other->_cached_size_);
    }
  }
  
  ::google::protobuf::Metadata CMsgGCToGCSOCacheSubscribe::GetMetadata() const {
    protobuf_AssignDescriptorsOnce();
    ::google::protobuf::Metadata metadata;
    metadata.descriptor = CMsgGCToGCSOCacheSubscribe_descriptor_;
    metadata.reflection = CMsgGCToGCSOCacheSubscribe_reflection_;
    return metadata;
  }
  
  
  // ===================================================================
  
  #ifndef _MSC_VER
  const int CMsgGCToGCSOCacheUnsubscribe::kSubscriberFieldNumber;
  const int CMsgGCToGCSOCacheUnsubscribe::kUnsubscribeFromFieldNumber;
  #endif  // !_MSC_VER
  
  CMsgGCToGCSOCacheUnsubscribe::CMsgGCToGCSOCacheUnsubscribe()
    : ::google::protobuf::Message() {
    SharedCtor();
  }
  
  void CMsgGCToGCSOCacheUnsubscribe::InitAsDefaultInstance() {
  }
  
  CMsgGCToGCSOCacheUnsubscribe::CMsgGCToGCSOCacheUnsubscribe(const CMsgGCToGCSOCacheUnsubscribe& from)
    : ::google::protobuf::Message() {
    SharedCtor();
    MergeFrom(from);
  }
  
  void CMsgGCToGCSOCacheUnsubscribe::SharedCtor() {
    _cached_size_ = 0;
    subscriber_ = GOOGLE_ULONGLONG(0);
    unsubscribe_from_ = GOOGLE_ULONGLONG(0);
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
  }
  
  CMsgGCToGCSOCacheUnsubscribe::~CMsgGCToGCSOCacheUnsubscribe() {
    SharedDtor();
  }
  
  void CMsgGCToGCSOCacheUnsubscribe::SharedDtor() {
    if (this != default_instance_) {
    }
  }
  
  void CMsgGCToGCSOCacheUnsubscribe::SetCachedSize(int size) const {
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
  }
  const ::google::protobuf::Descriptor* CMsgGCToGCSOCacheUnsubscribe::descriptor() {
    protobuf_AssignDescriptorsOnce();
    return CMsgGCToGCSOCacheUnsubscribe_descriptor_;
  }
  
  const CMsgGCToGCSOCacheUnsubscribe& CMsgGCToGCSOCacheUnsubscribe::default_instance() {
    if (default_instance_ == NULL) protobuf_AddDesc_gcsdk_5fgcmessages_2eproto();  return *default_instance_;
  }
  
  CMsgGCToGCSOCacheUnsubscribe* CMsgGCToGCSOCacheUnsubscribe::default_instance_ = NULL;
  
  CMsgGCToGCSOCacheUnsubscribe* CMsgGCToGCSOCacheUnsubscribe::New() const {
    return new CMsgGCToGCSOCacheUnsubscribe;
  }
  
  void CMsgGCToGCSOCacheUnsubscribe::Clear() {
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      subscriber_ = GOOGLE_ULONGLONG(0);
      unsubscribe_from_ = GOOGLE_ULONGLONG(0);
    }
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
    mutable_unknown_fields()->Clear();
  }
  
  bool CMsgGCToGCSOCacheUnsubscribe::MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) {
  #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
    ::google::protobuf::uint32 tag;
    while ((tag = input->ReadTag()) != 0) {
      switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
        // optional fixed64 subscriber = 1;
        case 1: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                   input, &subscriber_)));
            _set_bit(0);
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectTag(17)) goto parse_unsubscribe_from;
          break;
        }
        
        // optional fixed64 unsubscribe_from = 2;
        case 2: {
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
           parse_unsubscribe_from:
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                     ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                   input, &unsubscribe_from_)));
            _set_bit(1);
          } else {
            goto handle_uninterpreted;
          }
          if (input->ExpectAtEnd()) return true;
          break;
        }
        
        default: {
        handle_uninterpreted:
          if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
            return true;
          }
          DO_(::google::protobuf::internal::WireFormat::SkipField(
                input, tag, mutable_unknown_fields()));
          break;
        }
      }
    }
    return true;
  #undef DO_
  }
  
  void CMsgGCToGCSOCacheUnsubscribe::SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const {
    // optional fixed64 subscriber = 1;
    if (_has_bit(0)) {
      ::google::protobuf::internal::WireFormatLite::WriteFixed64(1, this->subscriber(), output);
    }
    
    // optional fixed64 unsubscribe_from = 2;
    if (_has_bit(1)) {
      ::google::protobuf::internal::WireFormatLite::WriteFixed64(2, this->unsubscribe_from(), output);
    }
    
    if (!unknown_fields().empty()) {
      ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
          unknown_fields(), output);
    }
  }
  
  ::google::protobuf::uint8* CMsgGCToGCSOCacheUnsubscribe::SerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const {
    // optional fixed64 subscriber = 1;
    if (_has_bit(0)) {
      target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(1, this->subscriber(), target);
    }
    
    // optional fixed64 unsubscribe_from = 2;
    if (_has_bit(1)) {
      target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(2, this->unsubscribe_from(), target);
    }
    
    if (!unknown_fields().empty()) {
      target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
          unknown_fields(), target);
    }
    return target;
  }
  
  int CMsgGCToGCSOCacheUnsubscribe::ByteSize() const {
    int total_size = 0;
    
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      // optional fixed64 subscriber = 1;
      if (has_subscriber()) {
        total_size += 1 + 8;
      }
      
      // optional fixed64 unsubscribe_from = 2;
      if (has_unsubscribe_from()) {
        total_size += 1 + 8;
      }
      
    }
    if (!unknown_fields().empty()) {
      total_size +=
        ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
          unknown_fields());
    }
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = total_size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
    return total_size;
  }
  
  void CMsgGCToGCSOCacheUnsubscribe::MergeFrom(const ::google::protobuf::Message& from) {
    GOOGLE_CHECK_NE(&from, this);
    const CMsgGCToGCSOCacheUnsubscribe* source =
      ::google::protobuf::internal::dynamic_cast_if_available<const CMsgGCToGCSOCacheUnsubscribe*>(
        &from);
    if (source == NULL) {
      ::google::protobuf::internal::ReflectionOps::Merge(from, this);
    } else {
      MergeFrom(*source);
    }
  }
  
  void CMsgGCToGCSOCacheUnsubscribe::MergeFrom(const CMsgGCToGCSOCacheUnsubscribe& from) {
    GOOGLE_CHECK_NE(&from, this);
    if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      if (from._has_bit(0)) {
        set_subscriber(from.subscriber());
      }
      if (from._has_bit(1)) {
        set_unsubscribe_from(from.unsubscribe_from());
      }
    }
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
  
  void CMsgGCToGCSOCacheUnsubscribe::CopyFrom(const ::google::protobuf::Message& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void CMsgGCToGCSOCacheUnsubscribe::CopyFrom(const CMsgGCToGCSOCacheUnsubscribe& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  bool CMsgGCToGCSOCacheUnsubscribe::IsInitialized() const {
    
    return true;
  }
  
  void CMsgGCToGCSOCacheUnsubscribe::Swap(CMsgGCToGCSOCacheUnsubscribe* other) {
    if (other != this) {
      std::swap(subscriber_, other->subscriber_);
      std::swap(unsubscribe_from_, other->unsubscribe_from_);
      std::swap(_has_bits_[0], other->_has_bits_[0]);
      _unknown_fields_.Swap(&other->_unknown_fields_);
      std::swap(_cached_size_, other->_cached_size_);
    }
  }
  
  ::google::protobuf::Metadata CMsgGCToGCSOCacheUnsubscribe::GetMetadata() const {
    protobuf_AssignDescriptorsOnce();
    ::google::protobuf::Metadata metadata;
    metadata.descriptor = CMsgGCToGCSOCacheUnsubscribe_descriptor_;
    metadata.reflection = CMsgGCToGCSOCacheUnsubscribe_reflection_;
    return metadata;
  }
  
  
  // ===================================================================
  
  #ifndef _MSC_VER
  #endif  // !_MSC_VER
  
  CMsgGCClientPing::CMsgGCClientPing()
    : ::google::protobuf::Message() {
    SharedCtor();
  }
  
  void CMsgGCClientPing::InitAsDefaultInstance() {
  }
  
  CMsgGCClientPing::CMsgGCClientPing(const CMsgGCClientPing& from)
    : ::google::protobuf::Message() {
    SharedCtor();
    MergeFrom(from);
  }
  
  void CMsgGCClientPing::SharedCtor() {
    _cached_size_ = 0;
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
  }
  
  CMsgGCClientPing::~CMsgGCClientPing() {
    SharedDtor();
  }
  
  void CMsgGCClientPing::SharedDtor() {
    if (this != default_instance_) {
    }
  }
  
  void CMsgGCClientPing::SetCachedSize(int size) const {
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
  }
  const ::google::protobuf::Descriptor* CMsgGCClientPing::descriptor() {
    protobuf_AssignDescriptorsOnce();
    return CMsgGCClientPing_descriptor_;
  }
  
  const CMsgGCClientPing& CMsgGCClientPing::default_instance() {
    if (default_instance_ == NULL) protobuf_AddDesc_gcsdk_5fgcmessages_2eproto();  return *default_instance_;
  }
  
  CMsgGCClientPing* CMsgGCClientPing::default_instance_ = NULL;
  
  CMsgGCClientPing* CMsgGCClientPing::New() const {
    return new CMsgGCClientPing;
  }
  
  void CMsgGCClientPing::Clear() {
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
    mutable_unknown_fields()->Clear();
  }
  
  bool CMsgGCClientPing::MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) {
  #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
    ::google::protobuf::uint32 tag;
    while ((tag = input->ReadTag()) != 0) {
      if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
          ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
        return true;
      }
      DO_(::google::protobuf::internal::WireFormat::SkipField(
            input, tag, mutable_unknown_fields()));
    }
    return true;
  #undef DO_
  }
  
  void CMsgGCClientPing::SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const {
    if (!unknown_fields().empty()) {
      ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
          unknown_fields(), output);
    }
  }
  
  ::google::protobuf::uint8* CMsgGCClientPing::SerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const {
    if (!unknown_fields().empty()) {
      target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
          unknown_fields(), target);
    }
    return target;
  }
  
  int CMsgGCClientPing::ByteSize() const {
    int total_size = 0;
    
    if (!unknown_fields().empty()) {
      total_size +=
        ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
          unknown_fields());
    }
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
    _cached_size_ = total_size;
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
    return total_size;
  }
  
  void CMsgGCClientPing::MergeFrom(const ::google::protobuf::Message& from) {
    GOOGLE_CHECK_NE(&from, this);
    const CMsgGCClientPing* source =
      ::google::protobuf::internal::dynamic_cast_if_available<const CMsgGCClientPing*>(
        &from);
    if (source == NULL) {
      ::google::protobuf::internal::ReflectionOps::Merge(from, this);
    } else {
      MergeFrom(*source);
    }
  }
  
  void CMsgGCClientPing::MergeFrom(const CMsgGCClientPing& from) {
    GOOGLE_CHECK_NE(&from, this);
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
  
  void CMsgGCClientPing::CopyFrom(const ::google::protobuf::Message& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void CMsgGCClientPing::CopyFrom(const CMsgGCClientPing& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  bool CMsgGCClientPing::IsInitialized() const {
    
    return true;
  }
  
  void CMsgGCClientPing::Swap(CMsgGCClientPing* other) {
    if (other != this) {
      _unknown_fields_.Swap(&other->_unknown_fields_);
      std::swap(_cached_size_, other->_cached_size_);
    }
  }
  
  ::google::protobuf::Metadata CMsgGCClientPing::GetMetadata() const {
    protobuf_AssignDescriptorsOnce();
    ::google::protobuf::Metadata metadata;
    metadata.descriptor = CMsgGCClientPing_descriptor_;
    metadata.reflection = CMsgGCClientPing_reflection_;
    return metadata;
  }
  
  
  // @@protoc_insertion_point(namespace_scope)
  
  // @@protoc_insertion_point(global_scope)
  #if _MSC_VER >= 1300
  #ifndef _PS3
  #pragma warning( pop )
  #endif // _PS3
  #endif // _MSC_VER
  #if _GNUC
  #ifndef _PS3
  #pragma GCC diagnostic pop
  #endif // _PS3
  #endif // _GNUC
  
  