hl2sdk/public/engine/protobuf/netmessages.pb.cc

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

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

#include <algorithm>

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

namespace {

const ::google::protobuf::Descriptor* CCLCMsg_ClientInfo_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CCLCMsg_ClientInfo_reflection_ = NULL;
const ::google::protobuf::Descriptor* CCLCMsg_Move_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CCLCMsg_Move_reflection_ = NULL;
const ::google::protobuf::Descriptor* CMsgVoiceAudio_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CMsgVoiceAudio_reflection_ = NULL;
const ::google::protobuf::Descriptor* CCLCMsg_VoiceData_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CCLCMsg_VoiceData_reflection_ = NULL;
const ::google::protobuf::Descriptor* CCLCMsg_BaselineAck_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CCLCMsg_BaselineAck_reflection_ = NULL;
const ::google::protobuf::Descriptor* CCLCMsg_ListenEvents_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CCLCMsg_ListenEvents_reflection_ = NULL;
const ::google::protobuf::Descriptor* CCLCMsg_RespondCvarValue_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CCLCMsg_RespondCvarValue_reflection_ = NULL;
const ::google::protobuf::Descriptor* CCLCMsg_FileCRCCheck_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CCLCMsg_FileCRCCheck_reflection_ = NULL;
const ::google::protobuf::Descriptor* CCLCMsg_LoadingProgress_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CCLCMsg_LoadingProgress_reflection_ = NULL;
const ::google::protobuf::Descriptor* CCLCMsg_SplitPlayerConnect_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CCLCMsg_SplitPlayerConnect_reflection_ = NULL;
const ::google::protobuf::Descriptor* CCLCMsg_ClientMessage_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CCLCMsg_ClientMessage_reflection_ = NULL;
const ::google::protobuf::Descriptor* CCLCMsg_SplitPlayerDisconnect_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CCLCMsg_SplitPlayerDisconnect_reflection_ = NULL;
const ::google::protobuf::Descriptor* CCLCMsg_ServerStatus_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CCLCMsg_ServerStatus_reflection_ = NULL;
const ::google::protobuf::Descriptor* CCLCMsg_ServerPing_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CCLCMsg_ServerPing_reflection_ = NULL;
const ::google::protobuf::Descriptor* CCLCMsg_RequestPause_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CCLCMsg_RequestPause_reflection_ = NULL;
const ::google::protobuf::Descriptor* CCLCMsg_CmdKeyValues_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CCLCMsg_CmdKeyValues_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_ServerInfo_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CSVCMsg_ServerInfo_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_ClassInfo_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CSVCMsg_ClassInfo_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_ClassInfo_class_t_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CSVCMsg_ClassInfo_class_t_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_SetPause_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CSVCMsg_SetPause_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_VoiceInit_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CSVCMsg_VoiceInit_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_Print_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CSVCMsg_Print_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_Sounds_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CSVCMsg_Sounds_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_Sounds_sounddata_t_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CSVCMsg_Sounds_sounddata_t_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_Prefetch_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CSVCMsg_Prefetch_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_SetView_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CSVCMsg_SetView_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_FixAngle_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CSVCMsg_FixAngle_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_CrosshairAngle_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CSVCMsg_CrosshairAngle_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_BSPDecal_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CSVCMsg_BSPDecal_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_SplitScreen_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CSVCMsg_SplitScreen_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_GetCvarValue_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CSVCMsg_GetCvarValue_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_Menu_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CSVCMsg_Menu_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_SendTable_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CSVCMsg_SendTable_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_SendTable_sendprop_t_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CSVCMsg_SendTable_sendprop_t_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_GameEventList_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CSVCMsg_GameEventList_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_GameEventList_key_t_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CSVCMsg_GameEventList_key_t_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_GameEventList_descriptor_t_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CSVCMsg_GameEventList_descriptor_t_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_PacketEntities_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CSVCMsg_PacketEntities_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_TempEntities_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CSVCMsg_TempEntities_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_CreateStringTable_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CSVCMsg_CreateStringTable_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_UpdateStringTable_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CSVCMsg_UpdateStringTable_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_VoiceData_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CSVCMsg_VoiceData_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_PacketReliable_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CSVCMsg_PacketReliable_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_FullFrameSplit_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CSVCMsg_FullFrameSplit_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_CmdKeyValues_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CSVCMsg_CmdKeyValues_reflection_ = NULL;
const ::google::protobuf::Descriptor* CMsgIPCAddress_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CMsgIPCAddress_reflection_ = NULL;
const ::google::protobuf::Descriptor* CMsgServerPeer_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CMsgServerPeer_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_PeerList_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CSVCMsg_PeerList_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_ClearAllStringTables_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CSVCMsg_ClearAllStringTables_reflection_ = NULL;
const ::google::protobuf::Descriptor* ProtoFlattenedSerializerField_t_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  ProtoFlattenedSerializerField_t_reflection_ = NULL;
const ::google::protobuf::Descriptor* ProtoFlattenedSerializer_t_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  ProtoFlattenedSerializer_t_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_FlattenedSerializer_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CSVCMsg_FlattenedSerializer_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_StopSound_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CSVCMsg_StopSound_reflection_ = NULL;
const ::google::protobuf::Descriptor* CBidirMsg_RebroadcastGameEvent_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CBidirMsg_RebroadcastGameEvent_reflection_ = NULL;
const ::google::protobuf::Descriptor* CBidirMsg_RebroadcastSource_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CBidirMsg_RebroadcastSource_reflection_ = NULL;
const ::google::protobuf::Descriptor* SerializedNetAddress_t_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  SerializedNetAddress_t_reflection_ = NULL;
const ::google::protobuf::Descriptor* CBidirMsg_RelayInfo_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CBidirMsg_RelayInfo_reflection_ = NULL;
const ::google::protobuf::EnumDescriptor* CBidirMsg_RelayInfo_Operation_t_descriptor_ = NULL;
const ::google::protobuf::Descriptor* SignedPayload_t_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  SignedPayload_t_reflection_ = NULL;
const ::google::protobuf::Descriptor* CBidirMsg_RelayPacket_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CBidirMsg_RelayPacket_reflection_ = NULL;
const ::google::protobuf::Descriptor* CBidirMsg_RelayPacket_SignedDestinationAddress_t_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CBidirMsg_RelayPacket_SignedDestinationAddress_t_reflection_ = NULL;
const ::google::protobuf::EnumDescriptor* CLC_Messages_descriptor_ = NULL;
const ::google::protobuf::EnumDescriptor* SVC_Messages_descriptor_ = NULL;
const ::google::protobuf::EnumDescriptor* VoiceDataFormat_t_descriptor_ = NULL;
const ::google::protobuf::EnumDescriptor* RequestPause_t_descriptor_ = NULL;
const ::google::protobuf::EnumDescriptor* PrefetchType_descriptor_ = NULL;
const ::google::protobuf::EnumDescriptor* ESplitScreenMessageType_descriptor_ = NULL;
const ::google::protobuf::EnumDescriptor* EQueryCvarValueStatus_descriptor_ = NULL;
const ::google::protobuf::EnumDescriptor* DIALOG_TYPE_descriptor_ = NULL;
const ::google::protobuf::EnumDescriptor* SVC_Messages_LowFrequency_descriptor_ = NULL;
const ::google::protobuf::EnumDescriptor* Bidirectional_Messages_descriptor_ = NULL;
const ::google::protobuf::EnumDescriptor* Bidirectional_Messages_LowFrequency_descriptor_ = NULL;

}  // namespace


void protobuf_AssignDesc_netmessages_2eproto() {
  protobuf_AddDesc_netmessages_2eproto();
  const ::google::protobuf::FileDescriptor* file =
    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
      "netmessages.proto");
  GOOGLE_CHECK(file != NULL);
  CCLCMsg_ClientInfo_descriptor_ = file->message_type(0);
  static const int CCLCMsg_ClientInfo_offsets_[7] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_ClientInfo, send_table_crc_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_ClientInfo, server_count_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_ClientInfo, is_hltv_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_ClientInfo, is_replay_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_ClientInfo, friends_id_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_ClientInfo, friends_name_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_ClientInfo, custom_files_),
  };
  CCLCMsg_ClientInfo_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CCLCMsg_ClientInfo_descriptor_,
      CCLCMsg_ClientInfo::default_instance_,
      CCLCMsg_ClientInfo_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_ClientInfo, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_ClientInfo, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CCLCMsg_ClientInfo));
  CCLCMsg_Move_descriptor_ = file->message_type(1);
  static const int CCLCMsg_Move_offsets_[3] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_Move, num_backup_commands_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_Move, num_new_commands_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_Move, data_),
  };
  CCLCMsg_Move_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CCLCMsg_Move_descriptor_,
      CCLCMsg_Move::default_instance_,
      CCLCMsg_Move_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_Move, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_Move, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CCLCMsg_Move));
  CMsgVoiceAudio_descriptor_ = file->message_type(2);
  static const int CMsgVoiceAudio_offsets_[6] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgVoiceAudio, format_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgVoiceAudio, voice_data_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgVoiceAudio, sequence_bytes_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgVoiceAudio, section_number_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgVoiceAudio, sample_rate_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgVoiceAudio, uncompressed_sample_offset_),
  };
  CMsgVoiceAudio_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CMsgVoiceAudio_descriptor_,
      CMsgVoiceAudio::default_instance_,
      CMsgVoiceAudio_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgVoiceAudio, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgVoiceAudio, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CMsgVoiceAudio));
  CCLCMsg_VoiceData_descriptor_ = file->message_type(3);
  static const int CCLCMsg_VoiceData_offsets_[3] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_VoiceData, audio_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_VoiceData, xuid_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_VoiceData, tick_),
  };
  CCLCMsg_VoiceData_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CCLCMsg_VoiceData_descriptor_,
      CCLCMsg_VoiceData::default_instance_,
      CCLCMsg_VoiceData_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_VoiceData, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_VoiceData, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CCLCMsg_VoiceData));
  CCLCMsg_BaselineAck_descriptor_ = file->message_type(4);
  static const int CCLCMsg_BaselineAck_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_BaselineAck, baseline_tick_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_BaselineAck, baseline_nr_),
  };
  CCLCMsg_BaselineAck_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CCLCMsg_BaselineAck_descriptor_,
      CCLCMsg_BaselineAck::default_instance_,
      CCLCMsg_BaselineAck_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_BaselineAck, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_BaselineAck, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CCLCMsg_BaselineAck));
  CCLCMsg_ListenEvents_descriptor_ = file->message_type(5);
  static const int CCLCMsg_ListenEvents_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_ListenEvents, event_mask_),
  };
  CCLCMsg_ListenEvents_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CCLCMsg_ListenEvents_descriptor_,
      CCLCMsg_ListenEvents::default_instance_,
      CCLCMsg_ListenEvents_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_ListenEvents, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_ListenEvents, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CCLCMsg_ListenEvents));
  CCLCMsg_RespondCvarValue_descriptor_ = file->message_type(6);
  static const int CCLCMsg_RespondCvarValue_offsets_[4] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_RespondCvarValue, cookie_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_RespondCvarValue, status_code_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_RespondCvarValue, name_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_RespondCvarValue, value_),
  };
  CCLCMsg_RespondCvarValue_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CCLCMsg_RespondCvarValue_descriptor_,
      CCLCMsg_RespondCvarValue::default_instance_,
      CCLCMsg_RespondCvarValue_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_RespondCvarValue, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_RespondCvarValue, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CCLCMsg_RespondCvarValue));
  CCLCMsg_FileCRCCheck_descriptor_ = file->message_type(7);
  static const int CCLCMsg_FileCRCCheck_offsets_[5] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_FileCRCCheck, code_path_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_FileCRCCheck, path_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_FileCRCCheck, code_filename_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_FileCRCCheck, filename_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_FileCRCCheck, crc_),
  };
  CCLCMsg_FileCRCCheck_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CCLCMsg_FileCRCCheck_descriptor_,
      CCLCMsg_FileCRCCheck::default_instance_,
      CCLCMsg_FileCRCCheck_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_FileCRCCheck, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_FileCRCCheck, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CCLCMsg_FileCRCCheck));
  CCLCMsg_LoadingProgress_descriptor_ = file->message_type(8);
  static const int CCLCMsg_LoadingProgress_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_LoadingProgress, progress_),
  };
  CCLCMsg_LoadingProgress_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CCLCMsg_LoadingProgress_descriptor_,
      CCLCMsg_LoadingProgress::default_instance_,
      CCLCMsg_LoadingProgress_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_LoadingProgress, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_LoadingProgress, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CCLCMsg_LoadingProgress));
  CCLCMsg_SplitPlayerConnect_descriptor_ = file->message_type(9);
  static const int CCLCMsg_SplitPlayerConnect_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_SplitPlayerConnect, playername_),
  };
  CCLCMsg_SplitPlayerConnect_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CCLCMsg_SplitPlayerConnect_descriptor_,
      CCLCMsg_SplitPlayerConnect::default_instance_,
      CCLCMsg_SplitPlayerConnect_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_SplitPlayerConnect, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_SplitPlayerConnect, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CCLCMsg_SplitPlayerConnect));
  CCLCMsg_ClientMessage_descriptor_ = file->message_type(10);
  static const int CCLCMsg_ClientMessage_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_ClientMessage, msg_type_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_ClientMessage, data_),
  };
  CCLCMsg_ClientMessage_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CCLCMsg_ClientMessage_descriptor_,
      CCLCMsg_ClientMessage::default_instance_,
      CCLCMsg_ClientMessage_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_ClientMessage, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_ClientMessage, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CCLCMsg_ClientMessage));
  CCLCMsg_SplitPlayerDisconnect_descriptor_ = file->message_type(11);
  static const int CCLCMsg_SplitPlayerDisconnect_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_SplitPlayerDisconnect, slot_),
  };
  CCLCMsg_SplitPlayerDisconnect_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CCLCMsg_SplitPlayerDisconnect_descriptor_,
      CCLCMsg_SplitPlayerDisconnect::default_instance_,
      CCLCMsg_SplitPlayerDisconnect_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_SplitPlayerDisconnect, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_SplitPlayerDisconnect, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CCLCMsg_SplitPlayerDisconnect));
  CCLCMsg_ServerStatus_descriptor_ = file->message_type(12);
  static const int CCLCMsg_ServerStatus_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_ServerStatus, simplified_),
  };
  CCLCMsg_ServerStatus_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CCLCMsg_ServerStatus_descriptor_,
      CCLCMsg_ServerStatus::default_instance_,
      CCLCMsg_ServerStatus_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_ServerStatus, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_ServerStatus, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CCLCMsg_ServerStatus));
  CCLCMsg_ServerPing_descriptor_ = file->message_type(13);
  static const int CCLCMsg_ServerPing_offsets_[1] = {
  };
  CCLCMsg_ServerPing_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CCLCMsg_ServerPing_descriptor_,
      CCLCMsg_ServerPing::default_instance_,
      CCLCMsg_ServerPing_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_ServerPing, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_ServerPing, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CCLCMsg_ServerPing));
  CCLCMsg_RequestPause_descriptor_ = file->message_type(14);
  static const int CCLCMsg_RequestPause_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_RequestPause, pause_type_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_RequestPause, pause_group_),
  };
  CCLCMsg_RequestPause_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CCLCMsg_RequestPause_descriptor_,
      CCLCMsg_RequestPause::default_instance_,
      CCLCMsg_RequestPause_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_RequestPause, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_RequestPause, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CCLCMsg_RequestPause));
  CCLCMsg_CmdKeyValues_descriptor_ = file->message_type(15);
  static const int CCLCMsg_CmdKeyValues_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_CmdKeyValues, data_),
  };
  CCLCMsg_CmdKeyValues_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CCLCMsg_CmdKeyValues_descriptor_,
      CCLCMsg_CmdKeyValues::default_instance_,
      CCLCMsg_CmdKeyValues_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_CmdKeyValues, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_CmdKeyValues, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CCLCMsg_CmdKeyValues));
  CSVCMsg_ServerInfo_descriptor_ = file->message_type(16);
  static const int CSVCMsg_ServerInfo_offsets_[20] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_ServerInfo, protocol_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_ServerInfo, server_count_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_ServerInfo, is_dedicated_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_ServerInfo, is_hltv_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_ServerInfo, is_replay_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_ServerInfo, c_os_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_ServerInfo, map_crc_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_ServerInfo, client_crc_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_ServerInfo, string_table_crc_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_ServerInfo, max_clients_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_ServerInfo, max_classes_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_ServerInfo, player_slot_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_ServerInfo, tick_interval_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_ServerInfo, game_dir_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_ServerInfo, map_name_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_ServerInfo, sky_name_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_ServerInfo, host_name_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_ServerInfo, addon_name_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_ServerInfo, game_session_config_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_ServerInfo, game_session_manifest_),
  };
  CSVCMsg_ServerInfo_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CSVCMsg_ServerInfo_descriptor_,
      CSVCMsg_ServerInfo::default_instance_,
      CSVCMsg_ServerInfo_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_ServerInfo, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_ServerInfo, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CSVCMsg_ServerInfo));
  CSVCMsg_ClassInfo_descriptor_ = file->message_type(17);
  static const int CSVCMsg_ClassInfo_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_ClassInfo, create_on_client_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_ClassInfo, classes_),
  };
  CSVCMsg_ClassInfo_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CSVCMsg_ClassInfo_descriptor_,
      CSVCMsg_ClassInfo::default_instance_,
      CSVCMsg_ClassInfo_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_ClassInfo, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_ClassInfo, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CSVCMsg_ClassInfo));
  CSVCMsg_ClassInfo_class_t_descriptor_ = CSVCMsg_ClassInfo_descriptor_->nested_type(0);
  static const int CSVCMsg_ClassInfo_class_t_offsets_[3] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_ClassInfo_class_t, class_id_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_ClassInfo_class_t, data_table_name_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_ClassInfo_class_t, class_name_),
  };
  CSVCMsg_ClassInfo_class_t_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CSVCMsg_ClassInfo_class_t_descriptor_,
      CSVCMsg_ClassInfo_class_t::default_instance_,
      CSVCMsg_ClassInfo_class_t_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_ClassInfo_class_t, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_ClassInfo_class_t, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CSVCMsg_ClassInfo_class_t));
  CSVCMsg_SetPause_descriptor_ = file->message_type(18);
  static const int CSVCMsg_SetPause_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_SetPause, paused_),
  };
  CSVCMsg_SetPause_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CSVCMsg_SetPause_descriptor_,
      CSVCMsg_SetPause::default_instance_,
      CSVCMsg_SetPause_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_SetPause, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_SetPause, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CSVCMsg_SetPause));
  CSVCMsg_VoiceInit_descriptor_ = file->message_type(19);
  static const int CSVCMsg_VoiceInit_offsets_[3] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_VoiceInit, quality_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_VoiceInit, codec_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_VoiceInit, version_),
  };
  CSVCMsg_VoiceInit_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CSVCMsg_VoiceInit_descriptor_,
      CSVCMsg_VoiceInit::default_instance_,
      CSVCMsg_VoiceInit_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_VoiceInit, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_VoiceInit, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CSVCMsg_VoiceInit));
  CSVCMsg_Print_descriptor_ = file->message_type(20);
  static const int CSVCMsg_Print_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Print, text_),
  };
  CSVCMsg_Print_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CSVCMsg_Print_descriptor_,
      CSVCMsg_Print::default_instance_,
      CSVCMsg_Print_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Print, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Print, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CSVCMsg_Print));
  CSVCMsg_Sounds_descriptor_ = file->message_type(21);
  static const int CSVCMsg_Sounds_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Sounds, reliable_sound_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Sounds, sounds_),
  };
  CSVCMsg_Sounds_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CSVCMsg_Sounds_descriptor_,
      CSVCMsg_Sounds::default_instance_,
      CSVCMsg_Sounds_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Sounds, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Sounds, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CSVCMsg_Sounds));
  CSVCMsg_Sounds_sounddata_t_descriptor_ = CSVCMsg_Sounds_descriptor_->nested_type(0);
  static const int CSVCMsg_Sounds_sounddata_t_offsets_[19] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Sounds_sounddata_t, origin_x_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Sounds_sounddata_t, origin_y_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Sounds_sounddata_t, origin_z_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Sounds_sounddata_t, volume_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Sounds_sounddata_t, delay_value_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Sounds_sounddata_t, sequence_number_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Sounds_sounddata_t, entity_index_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Sounds_sounddata_t, channel_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Sounds_sounddata_t, pitch_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Sounds_sounddata_t, flags_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Sounds_sounddata_t, sound_num_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Sounds_sounddata_t, sound_num_handle_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Sounds_sounddata_t, speaker_entity_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Sounds_sounddata_t, random_seed_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Sounds_sounddata_t, sound_level_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Sounds_sounddata_t, is_sentence_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Sounds_sounddata_t, is_ambient_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Sounds_sounddata_t, guid_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Sounds_sounddata_t, sound_resource_id_),
  };
  CSVCMsg_Sounds_sounddata_t_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CSVCMsg_Sounds_sounddata_t_descriptor_,
      CSVCMsg_Sounds_sounddata_t::default_instance_,
      CSVCMsg_Sounds_sounddata_t_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Sounds_sounddata_t, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Sounds_sounddata_t, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CSVCMsg_Sounds_sounddata_t));
  CSVCMsg_Prefetch_descriptor_ = file->message_type(22);
  static const int CSVCMsg_Prefetch_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Prefetch, sound_index_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Prefetch, resource_type_),
  };
  CSVCMsg_Prefetch_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CSVCMsg_Prefetch_descriptor_,
      CSVCMsg_Prefetch::default_instance_,
      CSVCMsg_Prefetch_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Prefetch, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Prefetch, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CSVCMsg_Prefetch));
  CSVCMsg_SetView_descriptor_ = file->message_type(23);
  static const int CSVCMsg_SetView_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_SetView, entity_index_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_SetView, slot_),
  };
  CSVCMsg_SetView_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CSVCMsg_SetView_descriptor_,
      CSVCMsg_SetView::default_instance_,
      CSVCMsg_SetView_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_SetView, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_SetView, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CSVCMsg_SetView));
  CSVCMsg_FixAngle_descriptor_ = file->message_type(24);
  static const int CSVCMsg_FixAngle_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_FixAngle, relative_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_FixAngle, angle_),
  };
  CSVCMsg_FixAngle_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CSVCMsg_FixAngle_descriptor_,
      CSVCMsg_FixAngle::default_instance_,
      CSVCMsg_FixAngle_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_FixAngle, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_FixAngle, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CSVCMsg_FixAngle));
  CSVCMsg_CrosshairAngle_descriptor_ = file->message_type(25);
  static const int CSVCMsg_CrosshairAngle_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_CrosshairAngle, angle_),
  };
  CSVCMsg_CrosshairAngle_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CSVCMsg_CrosshairAngle_descriptor_,
      CSVCMsg_CrosshairAngle::default_instance_,
      CSVCMsg_CrosshairAngle_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_CrosshairAngle, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_CrosshairAngle, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CSVCMsg_CrosshairAngle));
  CSVCMsg_BSPDecal_descriptor_ = file->message_type(26);
  static const int CSVCMsg_BSPDecal_offsets_[5] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_BSPDecal, pos_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_BSPDecal, decal_texture_index_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_BSPDecal, entity_index_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_BSPDecal, model_index_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_BSPDecal, low_priority_),
  };
  CSVCMsg_BSPDecal_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CSVCMsg_BSPDecal_descriptor_,
      CSVCMsg_BSPDecal::default_instance_,
      CSVCMsg_BSPDecal_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_BSPDecal, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_BSPDecal, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CSVCMsg_BSPDecal));
  CSVCMsg_SplitScreen_descriptor_ = file->message_type(27);
  static const int CSVCMsg_SplitScreen_offsets_[3] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_SplitScreen, type_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_SplitScreen, slot_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_SplitScreen, player_index_),
  };
  CSVCMsg_SplitScreen_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CSVCMsg_SplitScreen_descriptor_,
      CSVCMsg_SplitScreen::default_instance_,
      CSVCMsg_SplitScreen_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_SplitScreen, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_SplitScreen, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CSVCMsg_SplitScreen));
  CSVCMsg_GetCvarValue_descriptor_ = file->message_type(28);
  static const int CSVCMsg_GetCvarValue_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_GetCvarValue, cookie_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_GetCvarValue, cvar_name_),
  };
  CSVCMsg_GetCvarValue_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CSVCMsg_GetCvarValue_descriptor_,
      CSVCMsg_GetCvarValue::default_instance_,
      CSVCMsg_GetCvarValue_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_GetCvarValue, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_GetCvarValue, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CSVCMsg_GetCvarValue));
  CSVCMsg_Menu_descriptor_ = file->message_type(29);
  static const int CSVCMsg_Menu_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Menu, dialog_type_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Menu, menu_key_values_),
  };
  CSVCMsg_Menu_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CSVCMsg_Menu_descriptor_,
      CSVCMsg_Menu::default_instance_,
      CSVCMsg_Menu_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Menu, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Menu, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CSVCMsg_Menu));
  CSVCMsg_SendTable_descriptor_ = file->message_type(30);
  static const int CSVCMsg_SendTable_offsets_[4] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_SendTable, is_end_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_SendTable, net_table_name_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_SendTable, needs_decoder_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_SendTable, props_),
  };
  CSVCMsg_SendTable_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CSVCMsg_SendTable_descriptor_,
      CSVCMsg_SendTable::default_instance_,
      CSVCMsg_SendTable_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_SendTable, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_SendTable, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CSVCMsg_SendTable));
  CSVCMsg_SendTable_sendprop_t_descriptor_ = CSVCMsg_SendTable_descriptor_->nested_type(0);
  static const int CSVCMsg_SendTable_sendprop_t_offsets_[9] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_SendTable_sendprop_t, type_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_SendTable_sendprop_t, var_name_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_SendTable_sendprop_t, flags_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_SendTable_sendprop_t, priority_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_SendTable_sendprop_t, dt_name_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_SendTable_sendprop_t, num_elements_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_SendTable_sendprop_t, low_value_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_SendTable_sendprop_t, high_value_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_SendTable_sendprop_t, num_bits_),
  };
  CSVCMsg_SendTable_sendprop_t_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CSVCMsg_SendTable_sendprop_t_descriptor_,
      CSVCMsg_SendTable_sendprop_t::default_instance_,
      CSVCMsg_SendTable_sendprop_t_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_SendTable_sendprop_t, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_SendTable_sendprop_t, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CSVCMsg_SendTable_sendprop_t));
  CSVCMsg_GameEventList_descriptor_ = file->message_type(31);
  static const int CSVCMsg_GameEventList_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_GameEventList, descriptors_),
  };
  CSVCMsg_GameEventList_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CSVCMsg_GameEventList_descriptor_,
      CSVCMsg_GameEventList::default_instance_,
      CSVCMsg_GameEventList_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_GameEventList, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_GameEventList, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CSVCMsg_GameEventList));
  CSVCMsg_GameEventList_key_t_descriptor_ = CSVCMsg_GameEventList_descriptor_->nested_type(0);
  static const int CSVCMsg_GameEventList_key_t_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_GameEventList_key_t, type_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_GameEventList_key_t, name_),
  };
  CSVCMsg_GameEventList_key_t_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CSVCMsg_GameEventList_key_t_descriptor_,
      CSVCMsg_GameEventList_key_t::default_instance_,
      CSVCMsg_GameEventList_key_t_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_GameEventList_key_t, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_GameEventList_key_t, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CSVCMsg_GameEventList_key_t));
  CSVCMsg_GameEventList_descriptor_t_descriptor_ = CSVCMsg_GameEventList_descriptor_->nested_type(1);
  static const int CSVCMsg_GameEventList_descriptor_t_offsets_[3] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_GameEventList_descriptor_t, eventid_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_GameEventList_descriptor_t, name_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_GameEventList_descriptor_t, keys_),
  };
  CSVCMsg_GameEventList_descriptor_t_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CSVCMsg_GameEventList_descriptor_t_descriptor_,
      CSVCMsg_GameEventList_descriptor_t::default_instance_,
      CSVCMsg_GameEventList_descriptor_t_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_GameEventList_descriptor_t, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_GameEventList_descriptor_t, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CSVCMsg_GameEventList_descriptor_t));
  CSVCMsg_PacketEntities_descriptor_ = file->message_type(32);
  static const int CSVCMsg_PacketEntities_offsets_[10] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_PacketEntities, max_entries_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_PacketEntities, updated_entries_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_PacketEntities, is_delta_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_PacketEntities, update_baseline_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_PacketEntities, baseline_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_PacketEntities, delta_from_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_PacketEntities, entity_data_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_PacketEntities, pending_full_frame_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_PacketEntities, active_spawngroup_handle_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_PacketEntities, max_spawngroup_creationsequence_),
  };
  CSVCMsg_PacketEntities_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CSVCMsg_PacketEntities_descriptor_,
      CSVCMsg_PacketEntities::default_instance_,
      CSVCMsg_PacketEntities_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_PacketEntities, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_PacketEntities, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CSVCMsg_PacketEntities));
  CSVCMsg_TempEntities_descriptor_ = file->message_type(33);
  static const int CSVCMsg_TempEntities_offsets_[3] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_TempEntities, reliable_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_TempEntities, num_entries_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_TempEntities, entity_data_),
  };
  CSVCMsg_TempEntities_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CSVCMsg_TempEntities_descriptor_,
      CSVCMsg_TempEntities::default_instance_,
      CSVCMsg_TempEntities_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_TempEntities, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_TempEntities, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CSVCMsg_TempEntities));
  CSVCMsg_CreateStringTable_descriptor_ = file->message_type(34);
  static const int CSVCMsg_CreateStringTable_offsets_[9] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_CreateStringTable, name_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_CreateStringTable, num_entries_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_CreateStringTable, user_data_fixed_size_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_CreateStringTable, user_data_size_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_CreateStringTable, user_data_size_bits_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_CreateStringTable, flags_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_CreateStringTable, string_data_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_CreateStringTable, uncompressed_size_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_CreateStringTable, data_compressed_),
  };
  CSVCMsg_CreateStringTable_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CSVCMsg_CreateStringTable_descriptor_,
      CSVCMsg_CreateStringTable::default_instance_,
      CSVCMsg_CreateStringTable_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_CreateStringTable, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_CreateStringTable, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CSVCMsg_CreateStringTable));
  CSVCMsg_UpdateStringTable_descriptor_ = file->message_type(35);
  static const int CSVCMsg_UpdateStringTable_offsets_[3] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_UpdateStringTable, table_id_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_UpdateStringTable, num_changed_entries_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_UpdateStringTable, string_data_),
  };
  CSVCMsg_UpdateStringTable_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CSVCMsg_UpdateStringTable_descriptor_,
      CSVCMsg_UpdateStringTable::default_instance_,
      CSVCMsg_UpdateStringTable_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_UpdateStringTable, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_UpdateStringTable, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CSVCMsg_UpdateStringTable));
  CSVCMsg_VoiceData_descriptor_ = file->message_type(36);
  static const int CSVCMsg_VoiceData_offsets_[6] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_VoiceData, audio_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_VoiceData, client_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_VoiceData, proximity_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_VoiceData, xuid_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_VoiceData, audible_mask_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_VoiceData, tick_),
  };
  CSVCMsg_VoiceData_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CSVCMsg_VoiceData_descriptor_,
      CSVCMsg_VoiceData::default_instance_,
      CSVCMsg_VoiceData_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_VoiceData, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_VoiceData, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CSVCMsg_VoiceData));
  CSVCMsg_PacketReliable_descriptor_ = file->message_type(37);
  static const int CSVCMsg_PacketReliable_offsets_[3] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_PacketReliable, tick_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_PacketReliable, messagessize_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_PacketReliable, state_),
  };
  CSVCMsg_PacketReliable_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CSVCMsg_PacketReliable_descriptor_,
      CSVCMsg_PacketReliable::default_instance_,
      CSVCMsg_PacketReliable_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_PacketReliable, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_PacketReliable, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CSVCMsg_PacketReliable));
  CSVCMsg_FullFrameSplit_descriptor_ = file->message_type(38);
  static const int CSVCMsg_FullFrameSplit_offsets_[4] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_FullFrameSplit, tick_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_FullFrameSplit, section_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_FullFrameSplit, total_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_FullFrameSplit, data_),
  };
  CSVCMsg_FullFrameSplit_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CSVCMsg_FullFrameSplit_descriptor_,
      CSVCMsg_FullFrameSplit::default_instance_,
      CSVCMsg_FullFrameSplit_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_FullFrameSplit, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_FullFrameSplit, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CSVCMsg_FullFrameSplit));
  CSVCMsg_CmdKeyValues_descriptor_ = file->message_type(39);
  static const int CSVCMsg_CmdKeyValues_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_CmdKeyValues, data_),
  };
  CSVCMsg_CmdKeyValues_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CSVCMsg_CmdKeyValues_descriptor_,
      CSVCMsg_CmdKeyValues::default_instance_,
      CSVCMsg_CmdKeyValues_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_CmdKeyValues, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_CmdKeyValues, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CSVCMsg_CmdKeyValues));
  CMsgIPCAddress_descriptor_ = file->message_type(40);
  static const int CMsgIPCAddress_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgIPCAddress, computer_guid_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgIPCAddress, process_id_),
  };
  CMsgIPCAddress_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CMsgIPCAddress_descriptor_,
      CMsgIPCAddress::default_instance_,
      CMsgIPCAddress_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgIPCAddress, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgIPCAddress, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CMsgIPCAddress));
  CMsgServerPeer_descriptor_ = file->message_type(41);
  static const int CMsgServerPeer_offsets_[6] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgServerPeer, player_slot_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgServerPeer, steamid_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgServerPeer, ipc_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgServerPeer, they_hear_you_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgServerPeer, you_hear_them_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgServerPeer, is_listenserver_host_),
  };
  CMsgServerPeer_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CMsgServerPeer_descriptor_,
      CMsgServerPeer::default_instance_,
      CMsgServerPeer_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgServerPeer, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgServerPeer, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CMsgServerPeer));
  CSVCMsg_PeerList_descriptor_ = file->message_type(42);
  static const int CSVCMsg_PeerList_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_PeerList, peer_),
  };
  CSVCMsg_PeerList_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CSVCMsg_PeerList_descriptor_,
      CSVCMsg_PeerList::default_instance_,
      CSVCMsg_PeerList_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_PeerList, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_PeerList, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CSVCMsg_PeerList));
  CSVCMsg_ClearAllStringTables_descriptor_ = file->message_type(43);
  static const int CSVCMsg_ClearAllStringTables_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_ClearAllStringTables, mapname_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_ClearAllStringTables, map_crc_),
  };
  CSVCMsg_ClearAllStringTables_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CSVCMsg_ClearAllStringTables_descriptor_,
      CSVCMsg_ClearAllStringTables::default_instance_,
      CSVCMsg_ClearAllStringTables_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_ClearAllStringTables, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_ClearAllStringTables, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CSVCMsg_ClearAllStringTables));
  ProtoFlattenedSerializerField_t_descriptor_ = file->message_type(44);
  static const int ProtoFlattenedSerializerField_t_offsets_[9] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProtoFlattenedSerializerField_t, var_type_sym_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProtoFlattenedSerializerField_t, var_name_sym_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProtoFlattenedSerializerField_t, bit_count_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProtoFlattenedSerializerField_t, low_value_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProtoFlattenedSerializerField_t, high_value_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProtoFlattenedSerializerField_t, encode_flags_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProtoFlattenedSerializerField_t, field_serializer_name_sym_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProtoFlattenedSerializerField_t, field_serializer_version_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProtoFlattenedSerializerField_t, send_node_sym_),
  };
  ProtoFlattenedSerializerField_t_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      ProtoFlattenedSerializerField_t_descriptor_,
      ProtoFlattenedSerializerField_t::default_instance_,
      ProtoFlattenedSerializerField_t_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProtoFlattenedSerializerField_t, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProtoFlattenedSerializerField_t, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(ProtoFlattenedSerializerField_t));
  ProtoFlattenedSerializer_t_descriptor_ = file->message_type(45);
  static const int ProtoFlattenedSerializer_t_offsets_[3] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProtoFlattenedSerializer_t, serializer_name_sym_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProtoFlattenedSerializer_t, serializer_version_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProtoFlattenedSerializer_t, fields_index_),
  };
  ProtoFlattenedSerializer_t_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      ProtoFlattenedSerializer_t_descriptor_,
      ProtoFlattenedSerializer_t::default_instance_,
      ProtoFlattenedSerializer_t_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProtoFlattenedSerializer_t, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProtoFlattenedSerializer_t, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(ProtoFlattenedSerializer_t));
  CSVCMsg_FlattenedSerializer_descriptor_ = file->message_type(46);
  static const int CSVCMsg_FlattenedSerializer_offsets_[3] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_FlattenedSerializer, serializers_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_FlattenedSerializer, symbols_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_FlattenedSerializer, fields_),
  };
  CSVCMsg_FlattenedSerializer_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CSVCMsg_FlattenedSerializer_descriptor_,
      CSVCMsg_FlattenedSerializer::default_instance_,
      CSVCMsg_FlattenedSerializer_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_FlattenedSerializer, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_FlattenedSerializer, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CSVCMsg_FlattenedSerializer));
  CSVCMsg_StopSound_descriptor_ = file->message_type(47);
  static const int CSVCMsg_StopSound_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_StopSound, guid_),
  };
  CSVCMsg_StopSound_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CSVCMsg_StopSound_descriptor_,
      CSVCMsg_StopSound::default_instance_,
      CSVCMsg_StopSound_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_StopSound, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_StopSound, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CSVCMsg_StopSound));
  CBidirMsg_RebroadcastGameEvent_descriptor_ = file->message_type(48);
  static const int CBidirMsg_RebroadcastGameEvent_offsets_[4] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CBidirMsg_RebroadcastGameEvent, posttoserver_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CBidirMsg_RebroadcastGameEvent, buftype_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CBidirMsg_RebroadcastGameEvent, clientbitcount_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CBidirMsg_RebroadcastGameEvent, receivingclients_),
  };
  CBidirMsg_RebroadcastGameEvent_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CBidirMsg_RebroadcastGameEvent_descriptor_,
      CBidirMsg_RebroadcastGameEvent::default_instance_,
      CBidirMsg_RebroadcastGameEvent_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CBidirMsg_RebroadcastGameEvent, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CBidirMsg_RebroadcastGameEvent, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CBidirMsg_RebroadcastGameEvent));
  CBidirMsg_RebroadcastSource_descriptor_ = file->message_type(49);
  static const int CBidirMsg_RebroadcastSource_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CBidirMsg_RebroadcastSource, eventsource_),
  };
  CBidirMsg_RebroadcastSource_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CBidirMsg_RebroadcastSource_descriptor_,
      CBidirMsg_RebroadcastSource::default_instance_,
      CBidirMsg_RebroadcastSource_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CBidirMsg_RebroadcastSource, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CBidirMsg_RebroadcastSource, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CBidirMsg_RebroadcastSource));
  SerializedNetAddress_t_descriptor_ = file->message_type(50);
  static const int SerializedNetAddress_t_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SerializedNetAddress_t, serializedaddress_),
  };
  SerializedNetAddress_t_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      SerializedNetAddress_t_descriptor_,
      SerializedNetAddress_t::default_instance_,
      SerializedNetAddress_t_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SerializedNetAddress_t, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SerializedNetAddress_t, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(SerializedNetAddress_t));
  CBidirMsg_RelayInfo_descriptor_ = file->message_type(51);
  static const int CBidirMsg_RelayInfo_offsets_[3] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CBidirMsg_RelayInfo, operation_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CBidirMsg_RelayInfo, serializedtargetaddress_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CBidirMsg_RelayInfo, additionalhops_),
  };
  CBidirMsg_RelayInfo_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CBidirMsg_RelayInfo_descriptor_,
      CBidirMsg_RelayInfo::default_instance_,
      CBidirMsg_RelayInfo_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CBidirMsg_RelayInfo, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CBidirMsg_RelayInfo, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CBidirMsg_RelayInfo));
  CBidirMsg_RelayInfo_Operation_t_descriptor_ = CBidirMsg_RelayInfo_descriptor_->enum_type(0);
  SignedPayload_t_descriptor_ = file->message_type(52);
  static const int SignedPayload_t_offsets_[3] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SignedPayload_t, payloaddata_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SignedPayload_t, signature_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SignedPayload_t, bpayloadencrypted_),
  };
  SignedPayload_t_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      SignedPayload_t_descriptor_,
      SignedPayload_t::default_instance_,
      SignedPayload_t_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SignedPayload_t, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SignedPayload_t, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(SignedPayload_t));
  CBidirMsg_RelayPacket_descriptor_ = file->message_type(53);
  static const int CBidirMsg_RelayPacket_offsets_[4] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CBidirMsg_RelayPacket, prevhopcount_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CBidirMsg_RelayPacket, originalsender_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CBidirMsg_RelayPacket, signedpayload_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CBidirMsg_RelayPacket, recipientlist_),
  };
  CBidirMsg_RelayPacket_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CBidirMsg_RelayPacket_descriptor_,
      CBidirMsg_RelayPacket::default_instance_,
      CBidirMsg_RelayPacket_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CBidirMsg_RelayPacket, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CBidirMsg_RelayPacket, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CBidirMsg_RelayPacket));
  CBidirMsg_RelayPacket_SignedDestinationAddress_t_descriptor_ = CBidirMsg_RelayPacket_descriptor_->nested_type(0);
  static const int CBidirMsg_RelayPacket_SignedDestinationAddress_t_offsets_[3] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CBidirMsg_RelayPacket_SignedDestinationAddress_t, serializedaddr_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CBidirMsg_RelayPacket_SignedDestinationAddress_t, signature_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CBidirMsg_RelayPacket_SignedDestinationAddress_t, encryptedpayloadkey_),
  };
  CBidirMsg_RelayPacket_SignedDestinationAddress_t_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CBidirMsg_RelayPacket_SignedDestinationAddress_t_descriptor_,
      CBidirMsg_RelayPacket_SignedDestinationAddress_t::default_instance_,
      CBidirMsg_RelayPacket_SignedDestinationAddress_t_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CBidirMsg_RelayPacket_SignedDestinationAddress_t, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CBidirMsg_RelayPacket_SignedDestinationAddress_t, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CBidirMsg_RelayPacket_SignedDestinationAddress_t));
  CLC_Messages_descriptor_ = file->enum_type(0);
  SVC_Messages_descriptor_ = file->enum_type(1);
  VoiceDataFormat_t_descriptor_ = file->enum_type(2);
  RequestPause_t_descriptor_ = file->enum_type(3);
  PrefetchType_descriptor_ = file->enum_type(4);
  ESplitScreenMessageType_descriptor_ = file->enum_type(5);
  EQueryCvarValueStatus_descriptor_ = file->enum_type(6);
  DIALOG_TYPE_descriptor_ = file->enum_type(7);
  SVC_Messages_LowFrequency_descriptor_ = file->enum_type(8);
  Bidirectional_Messages_descriptor_ = file->enum_type(9);
  Bidirectional_Messages_LowFrequency_descriptor_ = file->enum_type(10);
}

namespace {

GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
inline void protobuf_AssignDescriptorsOnce() {
  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
                 &protobuf_AssignDesc_netmessages_2eproto);
}

void protobuf_RegisterTypes(const ::std::string&) {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CCLCMsg_ClientInfo_descriptor_, &CCLCMsg_ClientInfo::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CCLCMsg_Move_descriptor_, &CCLCMsg_Move::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CMsgVoiceAudio_descriptor_, &CMsgVoiceAudio::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CCLCMsg_VoiceData_descriptor_, &CCLCMsg_VoiceData::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CCLCMsg_BaselineAck_descriptor_, &CCLCMsg_BaselineAck::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CCLCMsg_ListenEvents_descriptor_, &CCLCMsg_ListenEvents::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CCLCMsg_RespondCvarValue_descriptor_, &CCLCMsg_RespondCvarValue::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CCLCMsg_FileCRCCheck_descriptor_, &CCLCMsg_FileCRCCheck::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CCLCMsg_LoadingProgress_descriptor_, &CCLCMsg_LoadingProgress::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CCLCMsg_SplitPlayerConnect_descriptor_, &CCLCMsg_SplitPlayerConnect::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CCLCMsg_ClientMessage_descriptor_, &CCLCMsg_ClientMessage::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CCLCMsg_SplitPlayerDisconnect_descriptor_, &CCLCMsg_SplitPlayerDisconnect::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CCLCMsg_ServerStatus_descriptor_, &CCLCMsg_ServerStatus::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CCLCMsg_ServerPing_descriptor_, &CCLCMsg_ServerPing::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CCLCMsg_RequestPause_descriptor_, &CCLCMsg_RequestPause::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CCLCMsg_CmdKeyValues_descriptor_, &CCLCMsg_CmdKeyValues::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CSVCMsg_ServerInfo_descriptor_, &CSVCMsg_ServerInfo::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CSVCMsg_ClassInfo_descriptor_, &CSVCMsg_ClassInfo::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CSVCMsg_ClassInfo_class_t_descriptor_, &CSVCMsg_ClassInfo_class_t::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CSVCMsg_SetPause_descriptor_, &CSVCMsg_SetPause::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CSVCMsg_VoiceInit_descriptor_, &CSVCMsg_VoiceInit::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CSVCMsg_Print_descriptor_, &CSVCMsg_Print::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CSVCMsg_Sounds_descriptor_, &CSVCMsg_Sounds::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CSVCMsg_Sounds_sounddata_t_descriptor_, &CSVCMsg_Sounds_sounddata_t::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CSVCMsg_Prefetch_descriptor_, &CSVCMsg_Prefetch::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CSVCMsg_SetView_descriptor_, &CSVCMsg_SetView::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CSVCMsg_FixAngle_descriptor_, &CSVCMsg_FixAngle::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CSVCMsg_CrosshairAngle_descriptor_, &CSVCMsg_CrosshairAngle::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CSVCMsg_BSPDecal_descriptor_, &CSVCMsg_BSPDecal::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CSVCMsg_SplitScreen_descriptor_, &CSVCMsg_SplitScreen::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CSVCMsg_GetCvarValue_descriptor_, &CSVCMsg_GetCvarValue::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CSVCMsg_Menu_descriptor_, &CSVCMsg_Menu::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CSVCMsg_SendTable_descriptor_, &CSVCMsg_SendTable::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CSVCMsg_SendTable_sendprop_t_descriptor_, &CSVCMsg_SendTable_sendprop_t::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CSVCMsg_GameEventList_descriptor_, &CSVCMsg_GameEventList::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CSVCMsg_GameEventList_key_t_descriptor_, &CSVCMsg_GameEventList_key_t::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CSVCMsg_GameEventList_descriptor_t_descriptor_, &CSVCMsg_GameEventList_descriptor_t::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CSVCMsg_PacketEntities_descriptor_, &CSVCMsg_PacketEntities::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CSVCMsg_TempEntities_descriptor_, &CSVCMsg_TempEntities::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CSVCMsg_CreateStringTable_descriptor_, &CSVCMsg_CreateStringTable::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CSVCMsg_UpdateStringTable_descriptor_, &CSVCMsg_UpdateStringTable::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CSVCMsg_VoiceData_descriptor_, &CSVCMsg_VoiceData::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CSVCMsg_PacketReliable_descriptor_, &CSVCMsg_PacketReliable::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CSVCMsg_FullFrameSplit_descriptor_, &CSVCMsg_FullFrameSplit::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CSVCMsg_CmdKeyValues_descriptor_, &CSVCMsg_CmdKeyValues::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CMsgIPCAddress_descriptor_, &CMsgIPCAddress::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CMsgServerPeer_descriptor_, &CMsgServerPeer::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CSVCMsg_PeerList_descriptor_, &CSVCMsg_PeerList::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CSVCMsg_ClearAllStringTables_descriptor_, &CSVCMsg_ClearAllStringTables::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    ProtoFlattenedSerializerField_t_descriptor_, &ProtoFlattenedSerializerField_t::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    ProtoFlattenedSerializer_t_descriptor_, &ProtoFlattenedSerializer_t::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CSVCMsg_FlattenedSerializer_descriptor_, &CSVCMsg_FlattenedSerializer::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CSVCMsg_StopSound_descriptor_, &CSVCMsg_StopSound::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CBidirMsg_RebroadcastGameEvent_descriptor_, &CBidirMsg_RebroadcastGameEvent::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CBidirMsg_RebroadcastSource_descriptor_, &CBidirMsg_RebroadcastSource::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    SerializedNetAddress_t_descriptor_, &SerializedNetAddress_t::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CBidirMsg_RelayInfo_descriptor_, &CBidirMsg_RelayInfo::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    SignedPayload_t_descriptor_, &SignedPayload_t::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CBidirMsg_RelayPacket_descriptor_, &CBidirMsg_RelayPacket::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CBidirMsg_RelayPacket_SignedDestinationAddress_t_descriptor_, &CBidirMsg_RelayPacket_SignedDestinationAddress_t::default_instance());
}

}  // namespace

void protobuf_ShutdownFile_netmessages_2eproto() {
  delete CCLCMsg_ClientInfo::default_instance_;
  delete CCLCMsg_ClientInfo_reflection_;
  delete CCLCMsg_Move::default_instance_;
  delete CCLCMsg_Move_reflection_;
  delete CMsgVoiceAudio::default_instance_;
  delete CMsgVoiceAudio_reflection_;
  delete CCLCMsg_VoiceData::default_instance_;
  delete CCLCMsg_VoiceData_reflection_;
  delete CCLCMsg_BaselineAck::default_instance_;
  delete CCLCMsg_BaselineAck_reflection_;
  delete CCLCMsg_ListenEvents::default_instance_;
  delete CCLCMsg_ListenEvents_reflection_;
  delete CCLCMsg_RespondCvarValue::default_instance_;
  delete CCLCMsg_RespondCvarValue_reflection_;
  delete CCLCMsg_FileCRCCheck::default_instance_;
  delete CCLCMsg_FileCRCCheck_reflection_;
  delete CCLCMsg_LoadingProgress::default_instance_;
  delete CCLCMsg_LoadingProgress_reflection_;
  delete CCLCMsg_SplitPlayerConnect::default_instance_;
  delete CCLCMsg_SplitPlayerConnect_reflection_;
  delete CCLCMsg_ClientMessage::default_instance_;
  delete CCLCMsg_ClientMessage_reflection_;
  delete CCLCMsg_SplitPlayerDisconnect::default_instance_;
  delete CCLCMsg_SplitPlayerDisconnect_reflection_;
  delete CCLCMsg_ServerStatus::default_instance_;
  delete CCLCMsg_ServerStatus_reflection_;
  delete CCLCMsg_ServerPing::default_instance_;
  delete CCLCMsg_ServerPing_reflection_;
  delete CCLCMsg_RequestPause::default_instance_;
  delete CCLCMsg_RequestPause_reflection_;
  delete CCLCMsg_CmdKeyValues::default_instance_;
  delete CCLCMsg_CmdKeyValues_reflection_;
  delete CSVCMsg_ServerInfo::default_instance_;
  delete CSVCMsg_ServerInfo_reflection_;
  delete CSVCMsg_ClassInfo::default_instance_;
  delete CSVCMsg_ClassInfo_reflection_;
  delete CSVCMsg_ClassInfo_class_t::default_instance_;
  delete CSVCMsg_ClassInfo_class_t_reflection_;
  delete CSVCMsg_SetPause::default_instance_;
  delete CSVCMsg_SetPause_reflection_;
  delete CSVCMsg_VoiceInit::default_instance_;
  delete CSVCMsg_VoiceInit_reflection_;
  delete CSVCMsg_Print::default_instance_;
  delete CSVCMsg_Print_reflection_;
  delete CSVCMsg_Sounds::default_instance_;
  delete CSVCMsg_Sounds_reflection_;
  delete CSVCMsg_Sounds_sounddata_t::default_instance_;
  delete CSVCMsg_Sounds_sounddata_t_reflection_;
  delete CSVCMsg_Prefetch::default_instance_;
  delete CSVCMsg_Prefetch_reflection_;
  delete CSVCMsg_SetView::default_instance_;
  delete CSVCMsg_SetView_reflection_;
  delete CSVCMsg_FixAngle::default_instance_;
  delete CSVCMsg_FixAngle_reflection_;
  delete CSVCMsg_CrosshairAngle::default_instance_;
  delete CSVCMsg_CrosshairAngle_reflection_;
  delete CSVCMsg_BSPDecal::default_instance_;
  delete CSVCMsg_BSPDecal_reflection_;
  delete CSVCMsg_SplitScreen::default_instance_;
  delete CSVCMsg_SplitScreen_reflection_;
  delete CSVCMsg_GetCvarValue::default_instance_;
  delete CSVCMsg_GetCvarValue_reflection_;
  delete CSVCMsg_Menu::default_instance_;
  delete CSVCMsg_Menu_reflection_;
  delete CSVCMsg_SendTable::default_instance_;
  delete CSVCMsg_SendTable_reflection_;
  delete CSVCMsg_SendTable_sendprop_t::default_instance_;
  delete CSVCMsg_SendTable_sendprop_t_reflection_;
  delete CSVCMsg_GameEventList::default_instance_;
  delete CSVCMsg_GameEventList_reflection_;
  delete CSVCMsg_GameEventList_key_t::default_instance_;
  delete CSVCMsg_GameEventList_key_t_reflection_;
  delete CSVCMsg_GameEventList_descriptor_t::default_instance_;
  delete CSVCMsg_GameEventList_descriptor_t_reflection_;
  delete CSVCMsg_PacketEntities::default_instance_;
  delete CSVCMsg_PacketEntities_reflection_;
  delete CSVCMsg_TempEntities::default_instance_;
  delete CSVCMsg_TempEntities_reflection_;
  delete CSVCMsg_CreateStringTable::default_instance_;
  delete CSVCMsg_CreateStringTable_reflection_;
  delete CSVCMsg_UpdateStringTable::default_instance_;
  delete CSVCMsg_UpdateStringTable_reflection_;
  delete CSVCMsg_VoiceData::default_instance_;
  delete CSVCMsg_VoiceData_reflection_;
  delete CSVCMsg_PacketReliable::default_instance_;
  delete CSVCMsg_PacketReliable_reflection_;
  delete CSVCMsg_FullFrameSplit::default_instance_;
  delete CSVCMsg_FullFrameSplit_reflection_;
  delete CSVCMsg_CmdKeyValues::default_instance_;
  delete CSVCMsg_CmdKeyValues_reflection_;
  delete CMsgIPCAddress::default_instance_;
  delete CMsgIPCAddress_reflection_;
  delete CMsgServerPeer::default_instance_;
  delete CMsgServerPeer_reflection_;
  delete CSVCMsg_PeerList::default_instance_;
  delete CSVCMsg_PeerList_reflection_;
  delete CSVCMsg_ClearAllStringTables::default_instance_;
  delete CSVCMsg_ClearAllStringTables_reflection_;
  delete ProtoFlattenedSerializerField_t::default_instance_;
  delete ProtoFlattenedSerializerField_t_reflection_;
  delete ProtoFlattenedSerializer_t::default_instance_;
  delete ProtoFlattenedSerializer_t_reflection_;
  delete CSVCMsg_FlattenedSerializer::default_instance_;
  delete CSVCMsg_FlattenedSerializer_reflection_;
  delete CSVCMsg_StopSound::default_instance_;
  delete CSVCMsg_StopSound_reflection_;
  delete CBidirMsg_RebroadcastGameEvent::default_instance_;
  delete CBidirMsg_RebroadcastGameEvent_reflection_;
  delete CBidirMsg_RebroadcastSource::default_instance_;
  delete CBidirMsg_RebroadcastSource_reflection_;
  delete SerializedNetAddress_t::default_instance_;
  delete SerializedNetAddress_t_reflection_;
  delete CBidirMsg_RelayInfo::default_instance_;
  delete CBidirMsg_RelayInfo_reflection_;
  delete SignedPayload_t::default_instance_;
  delete SignedPayload_t_reflection_;
  delete CBidirMsg_RelayPacket::default_instance_;
  delete CBidirMsg_RelayPacket_reflection_;
  delete CBidirMsg_RelayPacket_SignedDestinationAddress_t::default_instance_;
  delete CBidirMsg_RelayPacket_SignedDestinationAddress_t_reflection_;
}

void protobuf_AddDesc_netmessages_2eproto() {
  static bool already_here = false;
  if (already_here) return;
  already_here = true;
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  ::protobuf_AddDesc_networkbasetypes_2eproto();
  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
    "\n\021netmessages.proto\032\026networkbasetypes.pr"
    "oto\"\246\001\n\022CCLCMsg_ClientInfo\022\026\n\016send_table"
    "_crc\030\001 \001(\007\022\024\n\014server_count\030\002 \001(\r\022\017\n\007is_h"
    "ltv\030\003 \001(\010\022\021\n\tis_replay\030\004 \001(\010\022\022\n\nfriends_"
    "id\030\005 \001(\r\022\024\n\014friends_name\030\006 \001(\t\022\024\n\014custom"
    "_files\030\007 \003(\007\"S\n\014CCLCMsg_Move\022\033\n\023num_back"
    "up_commands\030\001 \001(\r\022\030\n\020num_new_commands\030\002 "
    "\001(\r\022\014\n\004data\030\003 \001(\014\"\311\001\n\016CMsgVoiceAudio\022:\n\006"
    "format\030\001 \001(\0162\022.VoiceDataFormat_t:\026VOICED"
    "ATA_FORMAT_STEAM\022\022\n\nvoice_data\030\002 \001(\014\022\026\n\016"
    "sequence_bytes\030\003 \001(\005\022\026\n\016section_number\030\004"
    " \001(\r\022\023\n\013sample_rate\030\005 \001(\r\022\"\n\032uncompresse"
    "d_sample_offset\030\006 \001(\r\"O\n\021CCLCMsg_VoiceDa"
    "ta\022\036\n\005audio\030\001 \001(\0132\017.CMsgVoiceAudio\022\014\n\004xu"
    "id\030\002 \001(\006\022\014\n\004tick\030\003 \001(\r\"A\n\023CCLCMsg_Baseli"
    "neAck\022\025\n\rbaseline_tick\030\001 \001(\005\022\023\n\013baseline"
    "_nr\030\002 \001(\005\"*\n\024CCLCMsg_ListenEvents\022\022\n\neve"
    "nt_mask\030\001 \003(\007\"\\\n\030CCLCMsg_RespondCvarValu"
    "e\022\016\n\006cookie\030\001 \001(\005\022\023\n\013status_code\030\002 \001(\005\022\014"
    "\n\004name\030\003 \001(\t\022\r\n\005value\030\004 \001(\t\"m\n\024CCLCMsg_F"
    "ileCRCCheck\022\021\n\tcode_path\030\001 \001(\005\022\014\n\004path\030\002"
    " \001(\t\022\025\n\rcode_filename\030\003 \001(\005\022\020\n\010filename\030"
    "\004 \001(\t\022\013\n\003crc\030\005 \001(\007\"+\n\027CCLCMsg_LoadingPro"
    "gress\022\020\n\010progress\030\001 \001(\005\"0\n\032CCLCMsg_Split"
    "PlayerConnect\022\022\n\nplayername\030\001 \001(\t\"7\n\025CCL"
    "CMsg_ClientMessage\022\020\n\010msg_type\030\001 \001(\005\022\014\n\004"
    "data\030\002 \001(\014\"-\n\035CCLCMsg_SplitPlayerDisconn"
    "ect\022\014\n\004slot\030\001 \001(\005\"*\n\024CCLCMsg_ServerStatu"
    "s\022\022\n\nsimplified\030\001 \001(\010\"\024\n\022CCLCMsg_ServerP"
    "ing\"Z\n\024CCLCMsg_RequestPause\022-\n\npause_typ"
    "e\030\001 \001(\0162\017.RequestPause_t:\010RP_PAUSE\022\023\n\013pa"
    "use_group\030\002 \001(\005\"$\n\024CCLCMsg_CmdKeyValues\022"
    "\014\n\004data\030\001 \001(\014\"\325\003\n\022CSVCMsg_ServerInfo\022\020\n\010"
    "protocol\030\001 \001(\005\022\024\n\014server_count\030\002 \001(\005\022\024\n\014"
    "is_dedicated\030\003 \001(\010\022\017\n\007is_hltv\030\004 \001(\010\022\021\n\ti"
    "s_replay\030\005 \001(\010\022\014\n\004c_os\030\006 \001(\005\022\017\n\007map_crc\030"
    "\007 \001(\007\022\022\n\nclient_crc\030\010 \001(\007\022\030\n\020string_tabl"
    "e_crc\030\t \001(\007\022\023\n\013max_clients\030\n \001(\005\022\023\n\013max_"
    "classes\030\013 \001(\005\022\023\n\013player_slot\030\014 \001(\005\022\025\n\rti"
    "ck_interval\030\r \001(\002\022\020\n\010game_dir\030\016 \001(\t\022\020\n\010m"
    "ap_name\030\017 \001(\t\022\020\n\010sky_name\030\020 \001(\t\022\021\n\thost_"
    "name\030\021 \001(\t\022\022\n\naddon_name\030\022 \001(\t\022>\n\023game_s"
    "ession_config\030\023 \001(\0132!.CSVCMsg_GameSessio"
    "nConfiguration\022\035\n\025game_session_manifest\030"
    "\024 \001(\014\"\244\001\n\021CSVCMsg_ClassInfo\022\030\n\020create_on"
    "_client\030\001 \001(\010\022+\n\007classes\030\002 \003(\0132\032.CSVCMsg"
    "_ClassInfo.class_t\032H\n\007class_t\022\020\n\010class_i"
    "d\030\001 \001(\005\022\027\n\017data_table_name\030\002 \001(\t\022\022\n\nclas"
    "s_name\030\003 \001(\t\"\"\n\020CSVCMsg_SetPause\022\016\n\006paus"
    "ed\030\001 \001(\010\"G\n\021CSVCMsg_VoiceInit\022\017\n\007quality"
    "\030\001 \001(\005\022\r\n\005codec\030\002 \001(\t\022\022\n\007version\030\003 \001(\005:\001"
    "0\"\035\n\rCSVCMsg_Print\022\014\n\004text\030\001 \001(\t\"\337\003\n\016CSV"
    "CMsg_Sounds\022\026\n\016reliable_sound\030\001 \001(\010\022+\n\006s"
    "ounds\030\002 \003(\0132\033.CSVCMsg_Sounds.sounddata_t"
    "\032\207\003\n\013sounddata_t\022\020\n\010origin_x\030\001 \001(\021\022\020\n\010or"
    "igin_y\030\002 \001(\021\022\020\n\010origin_z\030\003 \001(\021\022\016\n\006volume"
    "\030\004 \001(\r\022\023\n\013delay_value\030\005 \001(\002\022\027\n\017sequence_"
    "number\030\006 \001(\005\022\024\n\014entity_index\030\007 \001(\005\022\017\n\007ch"
    "annel\030\010 \001(\005\022\r\n\005pitch\030\t \001(\005\022\r\n\005flags\030\n \001("
    "\005\022\021\n\tsound_num\030\013 \001(\r\022\030\n\020sound_num_handle"
    "\030\014 \001(\007\022\026\n\016speaker_entity\030\r \001(\005\022\023\n\013random"
    "_seed\030\016 \001(\005\022\023\n\013sound_level\030\017 \001(\005\022\023\n\013is_s"
    "entence\030\020 \001(\010\022\022\n\nis_ambient\030\021 \001(\010\022\014\n\004gui"
    "d\030\022 \001(\r\022\031\n\021sound_resource_id\030\023 \001(\006\"X\n\020CS"
    "VCMsg_Prefetch\022\023\n\013sound_index\030\001 \001(\005\022/\n\rr"
    "esource_type\030\002 \001(\0162\r.PrefetchType:\tPFT_S"
    "OUND\"5\n\017CSVCMsg_SetView\022\024\n\014entity_index\030"
    "\001 \001(\005\022\014\n\004slot\030\002 \001(\005\"@\n\020CSVCMsg_FixAngle\022"
    "\020\n\010relative\030\001 \001(\010\022\032\n\005angle\030\002 \001(\0132\013.CMsgQ"
    "Angle\"4\n\026CSVCMsg_CrosshairAngle\022\032\n\005angle"
    "\030\001 \001(\0132\013.CMsgQAngle\"\212\001\n\020CSVCMsg_BSPDecal"
    "\022\030\n\003pos\030\001 \001(\0132\013.CMsgVector\022\033\n\023decal_text"
    "ure_index\030\002 \001(\005\022\024\n\014entity_index\030\003 \001(\005\022\023\n"
    "\013model_index\030\004 \001(\005\022\024\n\014low_priority\030\005 \001(\010"
    "\"z\n\023CSVCMsg_SplitScreen\022\?\n\004type\030\001 \001(\0162\030."
    "ESplitScreenMessageType:\027MSG_SPLITSCREEN"
    "_ADDUSER\022\014\n\004slot\030\002 \001(\005\022\024\n\014player_index\030\003"
    " \001(\005\"9\n\024CSVCMsg_GetCvarValue\022\016\n\006cookie\030\001"
    " \001(\005\022\021\n\tcvar_name\030\002 \001(\t\"<\n\014CSVCMsg_Menu\022"
    "\023\n\013dialog_type\030\001 \001(\005\022\027\n\017menu_key_values\030"
    "\002 \001(\014\"\260\002\n\021CSVCMsg_SendTable\022\016\n\006is_end\030\001 "
    "\001(\010\022\026\n\016net_table_name\030\002 \001(\t\022\025\n\rneeds_dec"
    "oder\030\003 \001(\010\022,\n\005props\030\004 \003(\0132\035.CSVCMsg_Send"
    "Table.sendprop_t\032\255\001\n\nsendprop_t\022\014\n\004type\030"
    "\001 \001(\005\022\020\n\010var_name\030\002 \001(\t\022\r\n\005flags\030\003 \001(\005\022\020"
    "\n\010priority\030\004 \001(\005\022\017\n\007dt_name\030\005 \001(\t\022\024\n\014num"
    "_elements\030\006 \001(\005\022\021\n\tlow_value\030\007 \001(\002\022\022\n\nhi"
    "gh_value\030\010 \001(\002\022\020\n\010num_bits\030\t \001(\005\"\321\001\n\025CSV"
    "CMsg_GameEventList\0228\n\013descriptors\030\001 \003(\0132"
    "#.CSVCMsg_GameEventList.descriptor_t\032#\n\005"
    "key_t\022\014\n\004type\030\001 \001(\005\022\014\n\004name\030\002 \001(\t\032Y\n\014des"
    "criptor_t\022\017\n\007eventid\030\001 \001(\005\022\014\n\004name\030\002 \001(\t"
    "\022*\n\004keys\030\003 \003(\0132\034.CSVCMsg_GameEventList.k"
    "ey_t\"\223\002\n\026CSVCMsg_PacketEntities\022\023\n\013max_e"
    "ntries\030\001 \001(\005\022\027\n\017updated_entries\030\002 \001(\005\022\020\n"
    "\010is_delta\030\003 \001(\010\022\027\n\017update_baseline\030\004 \001(\010"
    "\022\020\n\010baseline\030\005 \001(\005\022\022\n\ndelta_from\030\006 \001(\005\022\023"
    "\n\013entity_data\030\007 \001(\014\022\032\n\022pending_full_fram"
    "e\030\010 \001(\010\022 \n\030active_spawngroup_handle\030\t \001("
    "\r\022\'\n\037max_spawngroup_creationsequence\030\n \001"
    "(\r\"R\n\024CSVCMsg_TempEntities\022\020\n\010reliable\030\001"
    " \001(\010\022\023\n\013num_entries\030\002 \001(\005\022\023\n\013entity_data"
    "\030\003 \001(\014\"\351\001\n\031CSVCMsg_CreateStringTable\022\014\n\004"
    "name\030\001 \001(\t\022\023\n\013num_entries\030\002 \001(\005\022\034\n\024user_"
    "data_fixed_size\030\003 \001(\010\022\026\n\016user_data_size\030"
    "\004 \001(\005\022\033\n\023user_data_size_bits\030\005 \001(\005\022\r\n\005fl"
    "ags\030\006 \001(\005\022\023\n\013string_data\030\007 \001(\014\022\031\n\021uncomp"
    "ressed_size\030\010 \001(\005\022\027\n\017data_compressed\030\t \001"
    "(\010\"_\n\031CSVCMsg_UpdateStringTable\022\020\n\010table"
    "_id\030\001 \001(\005\022\033\n\023num_changed_entries\030\002 \001(\005\022\023"
    "\n\013string_data\030\003 \001(\014\"\210\001\n\021CSVCMsg_VoiceDat"
    "a\022\036\n\005audio\030\001 \001(\0132\017.CMsgVoiceAudio\022\016\n\006cli"
    "ent\030\002 \001(\005\022\021\n\tproximity\030\003 \001(\010\022\014\n\004xuid\030\004 \001"
    "(\006\022\024\n\014audible_mask\030\005 \001(\005\022\014\n\004tick\030\006 \001(\r\"K"
    "\n\026CSVCMsg_PacketReliable\022\014\n\004tick\030\001 \001(\005\022\024"
    "\n\014messagessize\030\002 \001(\005\022\r\n\005state\030\003 \001(\010\"T\n\026C"
    "SVCMsg_FullFrameSplit\022\014\n\004tick\030\001 \001(\005\022\017\n\007s"
    "ection\030\002 \001(\005\022\r\n\005total\030\003 \001(\005\022\014\n\004data\030\004 \001("
    "\014\"$\n\024CSVCMsg_CmdKeyValues\022\014\n\004data\030\001 \001(\014\""
    ";\n\016CMsgIPCAddress\022\025\n\rcomputer_guid\030\001 \001(\006"
    "\022\022\n\nprocess_id\030\002 \001(\r\"\240\001\n\016CMsgServerPeer\022"
    "\023\n\013player_slot\030\001 \001(\005\022\017\n\007steamid\030\002 \001(\006\022\034\n"
    "\003ipc\030\003 \001(\0132\017.CMsgIPCAddress\022\025\n\rthey_hear"
    "_you\030\004 \001(\010\022\025\n\ryou_hear_them\030\005 \001(\010\022\034\n\024is_"
    "listenserver_host\030\006 \001(\010\"1\n\020CSVCMsg_PeerL"
    "ist\022\035\n\004peer\030\001 \003(\0132\017.CMsgServerPeer\"@\n\034CS"
    "VCMsg_ClearAllStringTables\022\017\n\007mapname\030\001 "
    "\001(\t\022\017\n\007map_crc\030\002 \001(\r\"\371\001\n\037ProtoFlattenedS"
    "erializerField_t\022\024\n\014var_type_sym\030\001 \001(\005\022\024"
    "\n\014var_name_sym\030\002 \001(\005\022\021\n\tbit_count\030\003 \001(\005\022"
    "\021\n\tlow_value\030\004 \001(\002\022\022\n\nhigh_value\030\005 \001(\002\022\024"
    "\n\014encode_flags\030\006 \001(\005\022!\n\031field_serializer"
    "_name_sym\030\007 \001(\005\022 \n\030field_serializer_vers"
    "ion\030\010 \001(\005\022\025\n\rsend_node_sym\030\t \001(\005\"k\n\032Prot"
    "oFlattenedSerializer_t\022\033\n\023serializer_nam"
    "e_sym\030\001 \001(\005\022\032\n\022serializer_version\030\002 \001(\005\022"
    "\024\n\014fields_index\030\003 \003(\005\"\222\001\n\033CSVCMsg_Flatte"
    "nedSerializer\0220\n\013serializers\030\001 \003(\0132\033.Pro"
    "toFlattenedSerializer_t\022\017\n\007symbols\030\002 \003(\t"
    "\0220\n\006fields\030\003 \003(\0132 .ProtoFlattenedSeriali"
    "zerField_t\"!\n\021CSVCMsg_StopSound\022\014\n\004guid\030"
    "\001 \001(\007\"y\n\036CBidirMsg_RebroadcastGameEvent\022"
    "\024\n\014posttoserver\030\001 \001(\010\022\017\n\007buftype\030\002 \001(\005\022\026"
    "\n\016clientbitcount\030\003 \001(\r\022\030\n\020receivingclien"
    "ts\030\004 \001(\004\"2\n\033CBidirMsg_RebroadcastSource\022"
    "\023\n\013eventsource\030\001 \001(\005\"3\n\026SerializedNetAdd"
    "ress_t\022\031\n\021serializedAddress\030\001 \002(\014\"\257\002\n\023CB"
    "idirMsg_RelayInfo\022F\n\toperation\030\001 \002(\0162 .C"
    "BidirMsg_RelayInfo.Operation_t:\021RIO_REQU"
    "EST_RELAY\0228\n\027serializedTargetAddress\030\002 \001"
    "(\0132\027.SerializedNetAddress_t\022\026\n\016additiona"
    "lHops\030\003 \001(\r\"~\n\013Operation_t\022\025\n\021RIO_REQUES"
    "T_RELAY\020\000\022\022\n\016RIO_WILL_RELAY\020\001\022\020\n\014RIO_NO_"
    "ROUTE\020\002\022\024\n\020RIO_REJECT_RELAY\020\003\022\034\n\030RIO_EST"
    "ABLISH_CONNECTION\020\004\"T\n\017SignedPayload_t\022\023"
    "\n\013payloadData\030\001 \002(\014\022\021\n\tsignature\030\002 \002(\r\022\031"
    "\n\021bPayloadEncrypted\030\003 \002(\010\"\320\002\n\025CBidirMsg_"
    "RelayPacket\022\024\n\014prevhopcount\030\001 \002(\r\022/\n\016ori"
    "ginalSender\030\002 \002(\0132\027.SerializedNetAddress"
    "_t\022\'\n\rsignedPayload\030\003 \002(\0132\020.SignedPayloa"
    "d_t\022H\n\rrecipientList\030\004 \003(\01321.CBidirMsg_R"
    "elayPacket.SignedDestinationAddress_t\032}\n"
    "\032SignedDestinationAddress_t\022/\n\016serialize"
    "dAddr\030\001 \002(\0132\027.SerializedNetAddress_t\022\021\n\t"
    "signature\030\002 \002(\r\022\033\n\023encryptedPayloadKey\030\003"
    " \001(\014*\337\002\n\014CLC_Messages\022\022\n\016clc_ClientInfo\020"
    "\024\022\014\n\010clc_Move\020\025\022\021\n\rclc_VoiceData\020\026\022\023\n\017cl"
    "c_BaselineAck\020\027\022\024\n\020clc_ListenEvents\020\030\022\030\n"
    "\024clc_RespondCvarValue\020\031\022\024\n\020clc_FileCRCCh"
    "eck\020\032\022\027\n\023clc_LoadingProgress\020\033\022\032\n\026clc_Sp"
    "litPlayerConnect\020\034\022\025\n\021clc_ClientMessage\020"
    "\035\022\035\n\031clc_SplitPlayerDisconnect\020\036\022\024\n\020clc_"
    "ServerStatus\020\037\022\022\n\016clc_ServerPing\020 \022\024\n\020cl"
    "c_RequestPause\020!\022\024\n\020clc_CmdKeyValues\020\"*\326"
    "\004\n\014SVC_Messages\022\022\n\016svc_ServerInfo\020(\022\033\n\027s"
    "vc_FlattenedSerializer\020)\022\021\n\rsvc_ClassInf"
    "o\020*\022\020\n\014svc_SetPause\020+\022\031\n\025svc_CreateStrin"
    "gTable\020,\022\031\n\025svc_UpdateStringTable\020-\022\021\n\rs"
    "vc_VoiceInit\020.\022\021\n\rsvc_VoiceData\020/\022\r\n\tsvc"
    "_Print\0200\022\016\n\nsvc_Sounds\0201\022\017\n\013svc_SetView\020"
    "2\022\034\n\030svc_ClearAllStringTables\0203\022\024\n\020svc_C"
    "mdKeyValues\0204\022\020\n\014svc_BSPDecal\0205\022\023\n\017svc_S"
    "plitScreen\0206\022\026\n\022svc_PacketEntities\0207\022\020\n\014"
    "svc_Prefetch\0208\022\014\n\010svc_Menu\0209\022\024\n\020svc_GetC"
    "varValue\020:\022\021\n\rsvc_StopSound\020;\022\020\n\014svc_Pee"
    "rList\020<\022\026\n\022svc_PacketReliable\020=\022\023\n\017svc_U"
    "serMessage\020>\022\021\n\rsvc_SendTable\020\?\022\021\n\rsvc_G"
    "ameEvent\020C\022\024\n\020svc_TempEntities\020D\022\025\n\021svc_"
    "GameEventList\020E\022\026\n\022svc_FullFrameSplit\020F*"
    "L\n\021VoiceDataFormat_t\022\032\n\026VOICEDATA_FORMAT"
    "_STEAM\020\000\022\033\n\027VOICEDATA_FORMAT_ENGINE\020\001*B\n"
    "\016RequestPause_t\022\014\n\010RP_PAUSE\020\000\022\016\n\nRP_UNPA"
    "USE\020\001\022\022\n\016RP_TOGGLEPAUSE\020\002*\035\n\014PrefetchTyp"
    "e\022\r\n\tPFT_SOUND\020\000*V\n\027ESplitScreenMessageT"
    "ype\022\033\n\027MSG_SPLITSCREEN_ADDUSER\020\000\022\036\n\032MSG_"
    "SPLITSCREEN_REMOVEUSER\020\001*\263\001\n\025EQueryCvarV"
    "alueStatus\022%\n!eQueryCvarValueStatus_Valu"
    "eIntact\020\000\022&\n\"eQueryCvarValueStatus_CvarN"
    "otFound\020\001\022\"\n\036eQueryCvarValueStatus_NotAC"
    "var\020\002\022\'\n#eQueryCvarValueStatus_CvarProte"
    "cted\020\003*h\n\013DIALOG_TYPE\022\016\n\nDIALOG_MSG\020\000\022\017\n"
    "\013DIALOG_MENU\020\001\022\017\n\013DIALOG_TEXT\020\002\022\020\n\014DIALO"
    "G_ENTRY\020\003\022\025\n\021DIALOG_ASKCONNECT\020\004*+\n\031SVC_"
    "Messages_LowFrequency\022\016\n\tsvc_dummy\020\330\004*a\n"
    "\026Bidirectional_Messages\022\033\n\027bi_Rebroadcas"
    "tGameEvent\020\020\022\030\n\024bi_RebroadcastSource\020\021\022\020"
    "\n\014bi_GameEvent\020\022*M\n#Bidirectional_Messag"
    "es_LowFrequency\022\021\n\014bi_RelayInfo\020\274\005\022\023\n\016bi"
    "_RelayPacket\020\275\005B\003\200\001\000", 8340);
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
    "netmessages.proto", &protobuf_RegisterTypes);
  CCLCMsg_ClientInfo::default_instance_ = new CCLCMsg_ClientInfo();
  CCLCMsg_Move::default_instance_ = new CCLCMsg_Move();
  CMsgVoiceAudio::default_instance_ = new CMsgVoiceAudio();
  CCLCMsg_VoiceData::default_instance_ = new CCLCMsg_VoiceData();
  CCLCMsg_BaselineAck::default_instance_ = new CCLCMsg_BaselineAck();
  CCLCMsg_ListenEvents::default_instance_ = new CCLCMsg_ListenEvents();
  CCLCMsg_RespondCvarValue::default_instance_ = new CCLCMsg_RespondCvarValue();
  CCLCMsg_FileCRCCheck::default_instance_ = new CCLCMsg_FileCRCCheck();
  CCLCMsg_LoadingProgress::default_instance_ = new CCLCMsg_LoadingProgress();
  CCLCMsg_SplitPlayerConnect::default_instance_ = new CCLCMsg_SplitPlayerConnect();
  CCLCMsg_ClientMessage::default_instance_ = new CCLCMsg_ClientMessage();
  CCLCMsg_SplitPlayerDisconnect::default_instance_ = new CCLCMsg_SplitPlayerDisconnect();
  CCLCMsg_ServerStatus::default_instance_ = new CCLCMsg_ServerStatus();
  CCLCMsg_ServerPing::default_instance_ = new CCLCMsg_ServerPing();
  CCLCMsg_RequestPause::default_instance_ = new CCLCMsg_RequestPause();
  CCLCMsg_CmdKeyValues::default_instance_ = new CCLCMsg_CmdKeyValues();
  CSVCMsg_ServerInfo::default_instance_ = new CSVCMsg_ServerInfo();
  CSVCMsg_ClassInfo::default_instance_ = new CSVCMsg_ClassInfo();
  CSVCMsg_ClassInfo_class_t::default_instance_ = new CSVCMsg_ClassInfo_class_t();
  CSVCMsg_SetPause::default_instance_ = new CSVCMsg_SetPause();
  CSVCMsg_VoiceInit::default_instance_ = new CSVCMsg_VoiceInit();
  CSVCMsg_Print::default_instance_ = new CSVCMsg_Print();
  CSVCMsg_Sounds::default_instance_ = new CSVCMsg_Sounds();
  CSVCMsg_Sounds_sounddata_t::default_instance_ = new CSVCMsg_Sounds_sounddata_t();
  CSVCMsg_Prefetch::default_instance_ = new CSVCMsg_Prefetch();
  CSVCMsg_SetView::default_instance_ = new CSVCMsg_SetView();
  CSVCMsg_FixAngle::default_instance_ = new CSVCMsg_FixAngle();
  CSVCMsg_CrosshairAngle::default_instance_ = new CSVCMsg_CrosshairAngle();
  CSVCMsg_BSPDecal::default_instance_ = new CSVCMsg_BSPDecal();
  CSVCMsg_SplitScreen::default_instance_ = new CSVCMsg_SplitScreen();
  CSVCMsg_GetCvarValue::default_instance_ = new CSVCMsg_GetCvarValue();
  CSVCMsg_Menu::default_instance_ = new CSVCMsg_Menu();
  CSVCMsg_SendTable::default_instance_ = new CSVCMsg_SendTable();
  CSVCMsg_SendTable_sendprop_t::default_instance_ = new CSVCMsg_SendTable_sendprop_t();
  CSVCMsg_GameEventList::default_instance_ = new CSVCMsg_GameEventList();
  CSVCMsg_GameEventList_key_t::default_instance_ = new CSVCMsg_GameEventList_key_t();
  CSVCMsg_GameEventList_descriptor_t::default_instance_ = new CSVCMsg_GameEventList_descriptor_t();
  CSVCMsg_PacketEntities::default_instance_ = new CSVCMsg_PacketEntities();
  CSVCMsg_TempEntities::default_instance_ = new CSVCMsg_TempEntities();
  CSVCMsg_CreateStringTable::default_instance_ = new CSVCMsg_CreateStringTable();
  CSVCMsg_UpdateStringTable::default_instance_ = new CSVCMsg_UpdateStringTable();
  CSVCMsg_VoiceData::default_instance_ = new CSVCMsg_VoiceData();
  CSVCMsg_PacketReliable::default_instance_ = new CSVCMsg_PacketReliable();
  CSVCMsg_FullFrameSplit::default_instance_ = new CSVCMsg_FullFrameSplit();
  CSVCMsg_CmdKeyValues::default_instance_ = new CSVCMsg_CmdKeyValues();
  CMsgIPCAddress::default_instance_ = new CMsgIPCAddress();
  CMsgServerPeer::default_instance_ = new CMsgServerPeer();
  CSVCMsg_PeerList::default_instance_ = new CSVCMsg_PeerList();
  CSVCMsg_ClearAllStringTables::default_instance_ = new CSVCMsg_ClearAllStringTables();
  ProtoFlattenedSerializerField_t::default_instance_ = new ProtoFlattenedSerializerField_t();
  ProtoFlattenedSerializer_t::default_instance_ = new ProtoFlattenedSerializer_t();
  CSVCMsg_FlattenedSerializer::default_instance_ = new CSVCMsg_FlattenedSerializer();
  CSVCMsg_StopSound::default_instance_ = new CSVCMsg_StopSound();
  CBidirMsg_RebroadcastGameEvent::default_instance_ = new CBidirMsg_RebroadcastGameEvent();
  CBidirMsg_RebroadcastSource::default_instance_ = new CBidirMsg_RebroadcastSource();
  SerializedNetAddress_t::default_instance_ = new SerializedNetAddress_t();
  CBidirMsg_RelayInfo::default_instance_ = new CBidirMsg_RelayInfo();
  SignedPayload_t::default_instance_ = new SignedPayload_t();
  CBidirMsg_RelayPacket::default_instance_ = new CBidirMsg_RelayPacket();
  CBidirMsg_RelayPacket_SignedDestinationAddress_t::default_instance_ = new CBidirMsg_RelayPacket_SignedDestinationAddress_t();
  CCLCMsg_ClientInfo::default_instance_->InitAsDefaultInstance();
  CCLCMsg_Move::default_instance_->InitAsDefaultInstance();
  CMsgVoiceAudio::default_instance_->InitAsDefaultInstance();
  CCLCMsg_VoiceData::default_instance_->InitAsDefaultInstance();
  CCLCMsg_BaselineAck::default_instance_->InitAsDefaultInstance();
  CCLCMsg_ListenEvents::default_instance_->InitAsDefaultInstance();
  CCLCMsg_RespondCvarValue::default_instance_->InitAsDefaultInstance();
  CCLCMsg_FileCRCCheck::default_instance_->InitAsDefaultInstance();
  CCLCMsg_LoadingProgress::default_instance_->InitAsDefaultInstance();
  CCLCMsg_SplitPlayerConnect::default_instance_->InitAsDefaultInstance();
  CCLCMsg_ClientMessage::default_instance_->InitAsDefaultInstance();
  CCLCMsg_SplitPlayerDisconnect::default_instance_->InitAsDefaultInstance();
  CCLCMsg_ServerStatus::default_instance_->InitAsDefaultInstance();
  CCLCMsg_ServerPing::default_instance_->InitAsDefaultInstance();
  CCLCMsg_RequestPause::default_instance_->InitAsDefaultInstance();
  CCLCMsg_CmdKeyValues::default_instance_->InitAsDefaultInstance();
  CSVCMsg_ServerInfo::default_instance_->InitAsDefaultInstance();
  CSVCMsg_ClassInfo::default_instance_->InitAsDefaultInstance();
  CSVCMsg_ClassInfo_class_t::default_instance_->InitAsDefaultInstance();
  CSVCMsg_SetPause::default_instance_->InitAsDefaultInstance();
  CSVCMsg_VoiceInit::default_instance_->InitAsDefaultInstance();
  CSVCMsg_Print::default_instance_->InitAsDefaultInstance();
  CSVCMsg_Sounds::default_instance_->InitAsDefaultInstance();
  CSVCMsg_Sounds_sounddata_t::default_instance_->InitAsDefaultInstance();
  CSVCMsg_Prefetch::default_instance_->InitAsDefaultInstance();
  CSVCMsg_SetView::default_instance_->InitAsDefaultInstance();
  CSVCMsg_FixAngle::default_instance_->InitAsDefaultInstance();
  CSVCMsg_CrosshairAngle::default_instance_->InitAsDefaultInstance();
  CSVCMsg_BSPDecal::default_instance_->InitAsDefaultInstance();
  CSVCMsg_SplitScreen::default_instance_->InitAsDefaultInstance();
  CSVCMsg_GetCvarValue::default_instance_->InitAsDefaultInstance();
  CSVCMsg_Menu::default_instance_->InitAsDefaultInstance();
  CSVCMsg_SendTable::default_instance_->InitAsDefaultInstance();
  CSVCMsg_SendTable_sendprop_t::default_instance_->InitAsDefaultInstance();
  CSVCMsg_GameEventList::default_instance_->InitAsDefaultInstance();
  CSVCMsg_GameEventList_key_t::default_instance_->InitAsDefaultInstance();
  CSVCMsg_GameEventList_descriptor_t::default_instance_->InitAsDefaultInstance();
  CSVCMsg_PacketEntities::default_instance_->InitAsDefaultInstance();
  CSVCMsg_TempEntities::default_instance_->InitAsDefaultInstance();
  CSVCMsg_CreateStringTable::default_instance_->InitAsDefaultInstance();
  CSVCMsg_UpdateStringTable::default_instance_->InitAsDefaultInstance();
  CSVCMsg_VoiceData::default_instance_->InitAsDefaultInstance();
  CSVCMsg_PacketReliable::default_instance_->InitAsDefaultInstance();
  CSVCMsg_FullFrameSplit::default_instance_->InitAsDefaultInstance();
  CSVCMsg_CmdKeyValues::default_instance_->InitAsDefaultInstance();
  CMsgIPCAddress::default_instance_->InitAsDefaultInstance();
  CMsgServerPeer::default_instance_->InitAsDefaultInstance();
  CSVCMsg_PeerList::default_instance_->InitAsDefaultInstance();
  CSVCMsg_ClearAllStringTables::default_instance_->InitAsDefaultInstance();
  ProtoFlattenedSerializerField_t::default_instance_->InitAsDefaultInstance();
  ProtoFlattenedSerializer_t::default_instance_->InitAsDefaultInstance();
  CSVCMsg_FlattenedSerializer::default_instance_->InitAsDefaultInstance();
  CSVCMsg_StopSound::default_instance_->InitAsDefaultInstance();
  CBidirMsg_RebroadcastGameEvent::default_instance_->InitAsDefaultInstance();
  CBidirMsg_RebroadcastSource::default_instance_->InitAsDefaultInstance();
  SerializedNetAddress_t::default_instance_->InitAsDefaultInstance();
  CBidirMsg_RelayInfo::default_instance_->InitAsDefaultInstance();
  SignedPayload_t::default_instance_->InitAsDefaultInstance();
  CBidirMsg_RelayPacket::default_instance_->InitAsDefaultInstance();
  CBidirMsg_RelayPacket_SignedDestinationAddress_t::default_instance_->InitAsDefaultInstance();
  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_netmessages_2eproto);
}

// Force AddDescriptors() to be called at static initialization time.
struct StaticDescriptorInitializer_netmessages_2eproto {
  StaticDescriptorInitializer_netmessages_2eproto() {
    protobuf_AddDesc_netmessages_2eproto();
  }
} static_descriptor_initializer_netmessages_2eproto_;
const ::google::protobuf::EnumDescriptor* CLC_Messages_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return CLC_Messages_descriptor_;
}
bool CLC_Messages_IsValid(int value) {
  switch(value) {
    case 20:
    case 21:
    case 22:
    case 23:
    case 24:
    case 25:
    case 26:
    case 27:
    case 28:
    case 29:
    case 30:
    case 31:
    case 32:
    case 33:
    case 34:
      return true;
    default:
      return false;
  }
}

const ::google::protobuf::EnumDescriptor* SVC_Messages_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return SVC_Messages_descriptor_;
}
bool SVC_Messages_IsValid(int value) {
  switch(value) {
    case 40:
    case 41:
    case 42:
    case 43:
    case 44:
    case 45:
    case 46:
    case 47:
    case 48:
    case 49:
    case 50:
    case 51:
    case 52:
    case 53:
    case 54:
    case 55:
    case 56:
    case 57:
    case 58:
    case 59:
    case 60:
    case 61:
    case 62:
    case 63:
    case 67:
    case 68:
    case 69:
    case 70:
      return true;
    default:
      return false;
  }
}

const ::google::protobuf::EnumDescriptor* VoiceDataFormat_t_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return VoiceDataFormat_t_descriptor_;
}
bool VoiceDataFormat_t_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
      return true;
    default:
      return false;
  }
}

const ::google::protobuf::EnumDescriptor* RequestPause_t_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return RequestPause_t_descriptor_;
}
bool RequestPause_t_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

const ::google::protobuf::EnumDescriptor* PrefetchType_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return PrefetchType_descriptor_;
}
bool PrefetchType_IsValid(int value) {
  switch(value) {
    case 0:
      return true;
    default:
      return false;
  }
}

const ::google::protobuf::EnumDescriptor* ESplitScreenMessageType_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return ESplitScreenMessageType_descriptor_;
}
bool ESplitScreenMessageType_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
      return true;
    default:
      return false;
  }
}

const ::google::protobuf::EnumDescriptor* EQueryCvarValueStatus_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return EQueryCvarValueStatus_descriptor_;
}
bool EQueryCvarValueStatus_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
    case 2:
    case 3:
      return true;
    default:
      return false;
  }
}

const ::google::protobuf::EnumDescriptor* DIALOG_TYPE_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return DIALOG_TYPE_descriptor_;
}
bool DIALOG_TYPE_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
      return true;
    default:
      return false;
  }
}

const ::google::protobuf::EnumDescriptor* SVC_Messages_LowFrequency_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return SVC_Messages_LowFrequency_descriptor_;
}
bool SVC_Messages_LowFrequency_IsValid(int value) {
  switch(value) {
    case 600:
      return true;
    default:
      return false;
  }
}

const ::google::protobuf::EnumDescriptor* Bidirectional_Messages_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return Bidirectional_Messages_descriptor_;
}
bool Bidirectional_Messages_IsValid(int value) {
  switch(value) {
    case 16:
    case 17:
    case 18:
      return true;
    default:
      return false;
  }
}

const ::google::protobuf::EnumDescriptor* Bidirectional_Messages_LowFrequency_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return Bidirectional_Messages_LowFrequency_descriptor_;
}
bool Bidirectional_Messages_LowFrequency_IsValid(int value) {
  switch(value) {
    case 700:
    case 701:
      return true;
    default:
      return false;
  }
}


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

#ifndef _MSC_VER
const int CCLCMsg_ClientInfo::kSendTableCrcFieldNumber;
const int CCLCMsg_ClientInfo::kServerCountFieldNumber;
const int CCLCMsg_ClientInfo::kIsHltvFieldNumber;
const int CCLCMsg_ClientInfo::kIsReplayFieldNumber;
const int CCLCMsg_ClientInfo::kFriendsIdFieldNumber;
const int CCLCMsg_ClientInfo::kFriendsNameFieldNumber;
const int CCLCMsg_ClientInfo::kCustomFilesFieldNumber;
#endif  // !_MSC_VER

CCLCMsg_ClientInfo::CCLCMsg_ClientInfo()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:CCLCMsg_ClientInfo)
}

void CCLCMsg_ClientInfo::InitAsDefaultInstance() {
}

CCLCMsg_ClientInfo::CCLCMsg_ClientInfo(const CCLCMsg_ClientInfo& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:CCLCMsg_ClientInfo)
}

void CCLCMsg_ClientInfo::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  send_table_crc_ = 0u;
  server_count_ = 0u;
  is_hltv_ = false;
  is_replay_ = false;
  friends_id_ = 0u;
  friends_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CCLCMsg_ClientInfo::~CCLCMsg_ClientInfo() {
  // @@protoc_insertion_point(destructor:CCLCMsg_ClientInfo)
  SharedDtor();
}

void CCLCMsg_ClientInfo::SharedDtor() {
  if (friends_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete friends_name_;
  }
  if (this != default_instance_) {
  }
}

void CCLCMsg_ClientInfo::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CCLCMsg_ClientInfo::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return CCLCMsg_ClientInfo_descriptor_;
}

const CCLCMsg_ClientInfo& CCLCMsg_ClientInfo::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
  return *default_instance_;
}

CCLCMsg_ClientInfo* CCLCMsg_ClientInfo::default_instance_ = NULL;

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

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

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

  if (_has_bits_[0 / 32] & 63) {
    ZR_(send_table_crc_, friends_id_);
    if (has_friends_name()) {
      if (friends_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        friends_name_->clear();
      }
    }
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

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

bool CCLCMsg_ClientInfo::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:CCLCMsg_ClientInfo)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional fixed32 send_table_crc = 1;
      case 1: {
        if (tag == 13) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
                 input, &send_table_crc_)));
          set_has_send_table_crc();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_server_count;
        break;
      }

      // optional uint32 server_count = 2;
      case 2: {
        if (tag == 16) {
         parse_server_count:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &server_count_)));
          set_has_server_count();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_is_hltv;
        break;
      }

      // optional bool is_hltv = 3;
      case 3: {
        if (tag == 24) {
         parse_is_hltv:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &is_hltv_)));
          set_has_is_hltv();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(32)) goto parse_is_replay;
        break;
      }

      // optional bool is_replay = 4;
      case 4: {
        if (tag == 32) {
         parse_is_replay:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &is_replay_)));
          set_has_is_replay();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(40)) goto parse_friends_id;
        break;
      }

      // optional uint32 friends_id = 5;
      case 5: {
        if (tag == 40) {
         parse_friends_id:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &friends_id_)));
          set_has_friends_id();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(50)) goto parse_friends_name;
        break;
      }

      // optional string friends_name = 6;
      case 6: {
        if (tag == 50) {
         parse_friends_name:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_friends_name()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->friends_name().data(), this->friends_name().length(),
            ::google::protobuf::internal::WireFormat::PARSE,
            "friends_name");
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(61)) goto parse_custom_files;
        break;
      }

      // repeated fixed32 custom_files = 7;
      case 7: {
        if (tag == 61) {
         parse_custom_files:
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
                 1, 61, input, this->mutable_custom_files())));
        } else if (tag == 58) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
                 input, this->mutable_custom_files())));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(61)) goto parse_custom_files;
        if (input->ExpectAtEnd()) goto success;
        break;
      }

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

void CCLCMsg_ClientInfo::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:CCLCMsg_ClientInfo)
  // optional fixed32 send_table_crc = 1;
  if (has_send_table_crc()) {
    ::google::protobuf::internal::WireFormatLite::WriteFixed32(1, this->send_table_crc(), output);
  }

  // optional uint32 server_count = 2;
  if (has_server_count()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->server_count(), output);
  }

  // optional bool is_hltv = 3;
  if (has_is_hltv()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->is_hltv(), output);
  }

  // optional bool is_replay = 4;
  if (has_is_replay()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->is_replay(), output);
  }

  // optional uint32 friends_id = 5;
  if (has_friends_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(5, this->friends_id(), output);
  }

  // optional string friends_name = 6;
  if (has_friends_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->friends_name().data(), this->friends_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "friends_name");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      6, this->friends_name(), output);
  }

  // repeated fixed32 custom_files = 7;
  for (int i = 0; i < this->custom_files_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteFixed32(
      7, this->custom_files(i), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:CCLCMsg_ClientInfo)
}

::google::protobuf::uint8* CCLCMsg_ClientInfo::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:CCLCMsg_ClientInfo)
  // optional fixed32 send_table_crc = 1;
  if (has_send_table_crc()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(1, this->send_table_crc(), target);
  }

  // optional uint32 server_count = 2;
  if (has_server_count()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->server_count(), target);
  }

  // optional bool is_hltv = 3;
  if (has_is_hltv()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->is_hltv(), target);
  }

  // optional bool is_replay = 4;
  if (has_is_replay()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(4, this->is_replay(), target);
  }

  // optional uint32 friends_id = 5;
  if (has_friends_id()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(5, this->friends_id(), target);
  }

  // optional string friends_name = 6;
  if (has_friends_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->friends_name().data(), this->friends_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "friends_name");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        6, this->friends_name(), target);
  }

  // repeated fixed32 custom_files = 7;
  for (int i = 0; i < this->custom_files_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteFixed32ToArray(7, this->custom_files(i), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:CCLCMsg_ClientInfo)
  return target;
}

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional fixed32 send_table_crc = 1;
    if (has_send_table_crc()) {
      total_size += 1 + 4;
    }

    // optional uint32 server_count = 2;
    if (has_server_count()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->server_count());
    }

    // optional bool is_hltv = 3;
    if (has_is_hltv()) {
      total_size += 1 + 1;
    }

    // optional bool is_replay = 4;
    if (has_is_replay()) {
      total_size += 1 + 1;
    }

    // optional uint32 friends_id = 5;
    if (has_friends_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->friends_id());
    }

    // optional string friends_name = 6;
    if (has_friends_name()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->friends_name());
    }

  }
  // repeated fixed32 custom_files = 7;
  {
    int data_size = 0;
    data_size = 4 * this->custom_files_size();
    total_size += 1 * this->custom_files_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 CCLCMsg_ClientInfo::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const CCLCMsg_ClientInfo* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const CCLCMsg_ClientInfo*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void CCLCMsg_ClientInfo::MergeFrom(const CCLCMsg_ClientInfo& from) {
  GOOGLE_CHECK_NE(&from, this);
  custom_files_.MergeFrom(from.custom_files_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_send_table_crc()) {
      set_send_table_crc(from.send_table_crc());
    }
    if (from.has_server_count()) {
      set_server_count(from.server_count());
    }
    if (from.has_is_hltv()) {
      set_is_hltv(from.is_hltv());
    }
    if (from.has_is_replay()) {
      set_is_replay(from.is_replay());
    }
    if (from.has_friends_id()) {
      set_friends_id(from.friends_id());
    }
    if (from.has_friends_name()) {
      set_friends_name(from.friends_name());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void CCLCMsg_ClientInfo::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool CCLCMsg_ClientInfo::IsInitialized() const {

  return true;
}

void CCLCMsg_ClientInfo::Swap(CCLCMsg_ClientInfo* other) {
  if (other != this) {
    std::swap(send_table_crc_, other->send_table_crc_);
    std::swap(server_count_, other->server_count_);
    std::swap(is_hltv_, other->is_hltv_);
    std::swap(is_replay_, other->is_replay_);
    std::swap(friends_id_, other->friends_id_);
    std::swap(friends_name_, other->friends_name_);
    custom_files_.Swap(&other->custom_files_);
    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 CCLCMsg_ClientInfo::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CCLCMsg_ClientInfo_descriptor_;
  metadata.reflection = CCLCMsg_ClientInfo_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int CCLCMsg_Move::kNumBackupCommandsFieldNumber;
const int CCLCMsg_Move::kNumNewCommandsFieldNumber;
const int CCLCMsg_Move::kDataFieldNumber;
#endif  // !_MSC_VER

CCLCMsg_Move::CCLCMsg_Move()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:CCLCMsg_Move)
}

void CCLCMsg_Move::InitAsDefaultInstance() {
}

CCLCMsg_Move::CCLCMsg_Move(const CCLCMsg_Move& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:CCLCMsg_Move)
}

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

CCLCMsg_Move::~CCLCMsg_Move() {
  // @@protoc_insertion_point(destructor:CCLCMsg_Move)
  SharedDtor();
}

void CCLCMsg_Move::SharedDtor() {
  if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete data_;
  }
  if (this != default_instance_) {
  }
}

void CCLCMsg_Move::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CCLCMsg_Move::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return CCLCMsg_Move_descriptor_;
}

const CCLCMsg_Move& CCLCMsg_Move::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
  return *default_instance_;
}

CCLCMsg_Move* CCLCMsg_Move::default_instance_ = NULL;

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

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

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

  if (_has_bits_[0 / 32] & 7) {
    ZR_(num_backup_commands_, num_new_commands_);
    if (has_data()) {
      if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        data_->clear();
      }
    }
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

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

bool CCLCMsg_Move::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:CCLCMsg_Move)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional uint32 num_backup_commands = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &num_backup_commands_)));
          set_has_num_backup_commands();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_num_new_commands;
        break;
      }

      // optional uint32 num_new_commands = 2;
      case 2: {
        if (tag == 16) {
         parse_num_new_commands:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &num_new_commands_)));
          set_has_num_new_commands();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_data;
        break;
      }

      // optional bytes data = 3;
      case 3: {
        if (tag == 26) {
         parse_data:
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_data()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

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

void CCLCMsg_Move::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:CCLCMsg_Move)
  // optional uint32 num_backup_commands = 1;
  if (has_num_backup_commands()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->num_backup_commands(), output);
  }

  // optional uint32 num_new_commands = 2;
  if (has_num_new_commands()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->num_new_commands(), output);
  }

  // optional bytes data = 3;
  if (has_data()) {
    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
      3, this->data(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:CCLCMsg_Move)
}

::google::protobuf::uint8* CCLCMsg_Move::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:CCLCMsg_Move)
  // optional uint32 num_backup_commands = 1;
  if (has_num_backup_commands()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->num_backup_commands(), target);
  }

  // optional uint32 num_new_commands = 2;
  if (has_num_new_commands()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->num_new_commands(), target);
  }

  // optional bytes data = 3;
  if (has_data()) {
    target =
      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
        3, this->data(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:CCLCMsg_Move)
  return target;
}

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

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

    // optional uint32 num_new_commands = 2;
    if (has_num_new_commands()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->num_new_commands());
    }

    // optional bytes data = 3;
    if (has_data()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->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 CCLCMsg_Move::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const CCLCMsg_Move* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const CCLCMsg_Move*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void CCLCMsg_Move::MergeFrom(const CCLCMsg_Move& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_num_backup_commands()) {
      set_num_backup_commands(from.num_backup_commands());
    }
    if (from.has_num_new_commands()) {
      set_num_new_commands(from.num_new_commands());
    }
    if (from.has_data()) {
      set_data(from.data());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void CCLCMsg_Move::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool CCLCMsg_Move::IsInitialized() const {

  return true;
}

void CCLCMsg_Move::Swap(CCLCMsg_Move* other) {
  if (other != this) {
    std::swap(num_backup_commands_, other->num_backup_commands_);
    std::swap(num_new_commands_, other->num_new_commands_);
    std::swap(data_, other->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 CCLCMsg_Move::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CCLCMsg_Move_descriptor_;
  metadata.reflection = CCLCMsg_Move_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int CMsgVoiceAudio::kFormatFieldNumber;
const int CMsgVoiceAudio::kVoiceDataFieldNumber;
const int CMsgVoiceAudio::kSequenceBytesFieldNumber;
const int CMsgVoiceAudio::kSectionNumberFieldNumber;
const int CMsgVoiceAudio::kSampleRateFieldNumber;
const int CMsgVoiceAudio::kUncompressedSampleOffsetFieldNumber;
#endif  // !_MSC_VER

CMsgVoiceAudio::CMsgVoiceAudio()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:CMsgVoiceAudio)
}

void CMsgVoiceAudio::InitAsDefaultInstance() {
}

CMsgVoiceAudio::CMsgVoiceAudio(const CMsgVoiceAudio& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:CMsgVoiceAudio)
}

void CMsgVoiceAudio::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  format_ = 0;
  voice_data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  sequence_bytes_ = 0;
  section_number_ = 0u;
  sample_rate_ = 0u;
  uncompressed_sample_offset_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CMsgVoiceAudio::~CMsgVoiceAudio() {
  // @@protoc_insertion_point(destructor:CMsgVoiceAudio)
  SharedDtor();
}

void CMsgVoiceAudio::SharedDtor() {
  if (voice_data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete voice_data_;
  }
  if (this != default_instance_) {
  }
}

void CMsgVoiceAudio::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CMsgVoiceAudio::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return CMsgVoiceAudio_descriptor_;
}

const CMsgVoiceAudio& CMsgVoiceAudio::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
  return *default_instance_;
}

CMsgVoiceAudio* CMsgVoiceAudio::default_instance_ = NULL;

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

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

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

  if (_has_bits_[0 / 32] & 63) {
    ZR_(format_, uncompressed_sample_offset_);
    if (has_voice_data()) {
      if (voice_data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        voice_data_->clear();
      }
    }
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

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

bool CMsgVoiceAudio::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:CMsgVoiceAudio)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .VoiceDataFormat_t format = 1 [default = VOICEDATA_FORMAT_STEAM];
      case 1: {
        if (tag == 8) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::VoiceDataFormat_t_IsValid(value)) {
            set_format(static_cast< ::VoiceDataFormat_t >(value));
          } else {
            mutable_unknown_fields()->AddVarint(1, value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_voice_data;
        break;
      }

      // optional bytes voice_data = 2;
      case 2: {
        if (tag == 18) {
         parse_voice_data:
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_voice_data()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_sequence_bytes;
        break;
      }

      // optional int32 sequence_bytes = 3;
      case 3: {
        if (tag == 24) {
         parse_sequence_bytes:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &sequence_bytes_)));
          set_has_sequence_bytes();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(32)) goto parse_section_number;
        break;
      }

      // optional uint32 section_number = 4;
      case 4: {
        if (tag == 32) {
         parse_section_number:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &section_number_)));
          set_has_section_number();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(40)) goto parse_sample_rate;
        break;
      }

      // optional uint32 sample_rate = 5;
      case 5: {
        if (tag == 40) {
         parse_sample_rate:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &sample_rate_)));
          set_has_sample_rate();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(48)) goto parse_uncompressed_sample_offset;
        break;
      }

      // optional uint32 uncompressed_sample_offset = 6;
      case 6: {
        if (tag == 48) {
         parse_uncompressed_sample_offset:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &uncompressed_sample_offset_)));
          set_has_uncompressed_sample_offset();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

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

void CMsgVoiceAudio::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:CMsgVoiceAudio)
  // optional .VoiceDataFormat_t format = 1 [default = VOICEDATA_FORMAT_STEAM];
  if (has_format()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->format(), output);
  }

  // optional bytes voice_data = 2;
  if (has_voice_data()) {
    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
      2, this->voice_data(), output);
  }

  // optional int32 sequence_bytes = 3;
  if (has_sequence_bytes()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->sequence_bytes(), output);
  }

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

  // optional uint32 sample_rate = 5;
  if (has_sample_rate()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(5, this->sample_rate(), output);
  }

  // optional uint32 uncompressed_sample_offset = 6;
  if (has_uncompressed_sample_offset()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(6, this->uncompressed_sample_offset(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:CMsgVoiceAudio)
}

::google::protobuf::uint8* CMsgVoiceAudio::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:CMsgVoiceAudio)
  // optional .VoiceDataFormat_t format = 1 [default = VOICEDATA_FORMAT_STEAM];
  if (has_format()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->format(), target);
  }

  // optional bytes voice_data = 2;
  if (has_voice_data()) {
    target =
      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
        2, this->voice_data(), target);
  }

  // optional int32 sequence_bytes = 3;
  if (has_sequence_bytes()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->sequence_bytes(), target);
  }

  // optional uint32 section_number = 4;
  if (has_section_number()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(4, this->section_number(), target);
  }

  // optional uint32 sample_rate = 5;
  if (has_sample_rate()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(5, this->sample_rate(), target);
  }

  // optional uint32 uncompressed_sample_offset = 6;
  if (has_uncompressed_sample_offset()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(6, this->uncompressed_sample_offset(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:CMsgVoiceAudio)
  return target;
}

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional .VoiceDataFormat_t format = 1 [default = VOICEDATA_FORMAT_STEAM];
    if (has_format()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->format());
    }

    // optional bytes voice_data = 2;
    if (has_voice_data()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->voice_data());
    }

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

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

    // optional uint32 sample_rate = 5;
    if (has_sample_rate()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->sample_rate());
    }

    // optional uint32 uncompressed_sample_offset = 6;
    if (has_uncompressed_sample_offset()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->uncompressed_sample_offset());
    }

  }
  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 CMsgVoiceAudio::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const CMsgVoiceAudio* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const CMsgVoiceAudio*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void CMsgVoiceAudio::MergeFrom(const CMsgVoiceAudio& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_format()) {
      set_format(from.format());
    }
    if (from.has_voice_data()) {
      set_voice_data(from.voice_data());
    }
    if (from.has_sequence_bytes()) {
      set_sequence_bytes(from.sequence_bytes());
    }
    if (from.has_section_number()) {
      set_section_number(from.section_number());
    }
    if (from.has_sample_rate()) {
      set_sample_rate(from.sample_rate());
    }
    if (from.has_uncompressed_sample_offset()) {
      set_uncompressed_sample_offset(from.uncompressed_sample_offset());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void CMsgVoiceAudio::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool CMsgVoiceAudio::IsInitialized() const {

  return true;
}

void CMsgVoiceAudio::Swap(CMsgVoiceAudio* other) {
  if (other != this) {
    std::swap(format_, other->format_);
    std::swap(voice_data_, other->voice_data_);
    std::swap(sequence_bytes_, other->sequence_bytes_);
    std::swap(section_number_, other->section_number_);
    std::swap(sample_rate_, other->sample_rate_);
    std::swap(uncompressed_sample_offset_, other->uncompressed_sample_offset_);
    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 CMsgVoiceAudio::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CMsgVoiceAudio_descriptor_;
  metadata.reflection = CMsgVoiceAudio_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int CCLCMsg_VoiceData::kAudioFieldNumber;
const int CCLCMsg_VoiceData::kXuidFieldNumber;
const int CCLCMsg_VoiceData::kTickFieldNumber;
#endif  // !_MSC_VER

CCLCMsg_VoiceData::CCLCMsg_VoiceData()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:CCLCMsg_VoiceData)
}

void CCLCMsg_VoiceData::InitAsDefaultInstance() {
  audio_ = const_cast< ::CMsgVoiceAudio*>(&::CMsgVoiceAudio::default_instance());
}

CCLCMsg_VoiceData::CCLCMsg_VoiceData(const CCLCMsg_VoiceData& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:CCLCMsg_VoiceData)
}

void CCLCMsg_VoiceData::SharedCtor() {
  _cached_size_ = 0;
  audio_ = NULL;
  xuid_ = GOOGLE_ULONGLONG(0);
  tick_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CCLCMsg_VoiceData::~CCLCMsg_VoiceData() {
  // @@protoc_insertion_point(destructor:CCLCMsg_VoiceData)
  SharedDtor();
}

void CCLCMsg_VoiceData::SharedDtor() {
  if (this != default_instance_) {
    delete audio_;
  }
}

void CCLCMsg_VoiceData::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CCLCMsg_VoiceData::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return CCLCMsg_VoiceData_descriptor_;
}

const CCLCMsg_VoiceData& CCLCMsg_VoiceData::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
  return *default_instance_;
}

CCLCMsg_VoiceData* CCLCMsg_VoiceData::default_instance_ = NULL;

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

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

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

  if (_has_bits_[0 / 32] & 7) {
    ZR_(xuid_, tick_);
    if (has_audio()) {
      if (audio_ != NULL) audio_->::CMsgVoiceAudio::Clear();
    }
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

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

bool CCLCMsg_VoiceData::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:CCLCMsg_VoiceData)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .CMsgVoiceAudio audio = 1;
      case 1: {
        if (tag == 10) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_audio()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(17)) goto parse_xuid;
        break;
      }

      // optional fixed64 xuid = 2;
      case 2: {
        if (tag == 17) {
         parse_xuid:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                 input, &xuid_)));
          set_has_xuid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_tick;
        break;
      }

      // optional uint32 tick = 3;
      case 3: {
        if (tag == 24) {
         parse_tick:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &tick_)));
          set_has_tick();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

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

void CCLCMsg_VoiceData::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:CCLCMsg_VoiceData)
  // optional .CMsgVoiceAudio audio = 1;
  if (has_audio()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->audio(), output);
  }

  // optional fixed64 xuid = 2;
  if (has_xuid()) {
    ::google::protobuf::internal::WireFormatLite::WriteFixed64(2, this->xuid(), output);
  }

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

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:CCLCMsg_VoiceData)
}

::google::protobuf::uint8* CCLCMsg_VoiceData::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:CCLCMsg_VoiceData)
  // optional .CMsgVoiceAudio audio = 1;
  if (has_audio()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->audio(), target);
  }

  // optional fixed64 xuid = 2;
  if (has_xuid()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(2, this->xuid(), target);
  }

  // optional uint32 tick = 3;
  if (has_tick()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->tick(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:CCLCMsg_VoiceData)
  return target;
}

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional .CMsgVoiceAudio audio = 1;
    if (has_audio()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->audio());
    }

    // optional fixed64 xuid = 2;
    if (has_xuid()) {
      total_size += 1 + 8;
    }

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

  }
  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 CCLCMsg_VoiceData::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const CCLCMsg_VoiceData* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const CCLCMsg_VoiceData*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void CCLCMsg_VoiceData::MergeFrom(const CCLCMsg_VoiceData& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_audio()) {
      mutable_audio()->::CMsgVoiceAudio::MergeFrom(from.audio());
    }
    if (from.has_xuid()) {
      set_xuid(from.xuid());
    }
    if (from.has_tick()) {
      set_tick(from.tick());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void CCLCMsg_VoiceData::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool CCLCMsg_VoiceData::IsInitialized() const {

  return true;
}

void CCLCMsg_VoiceData::Swap(CCLCMsg_VoiceData* other) {
  if (other != this) {
    std::swap(audio_, other->audio_);
    std::swap(xuid_, other->xuid_);
    std::swap(tick_, other->tick_);
    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 CCLCMsg_VoiceData::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CCLCMsg_VoiceData_descriptor_;
  metadata.reflection = CCLCMsg_VoiceData_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int CCLCMsg_BaselineAck::kBaselineTickFieldNumber;
const int CCLCMsg_BaselineAck::kBaselineNrFieldNumber;
#endif  // !_MSC_VER

CCLCMsg_BaselineAck::CCLCMsg_BaselineAck()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:CCLCMsg_BaselineAck)
}

void CCLCMsg_BaselineAck::InitAsDefaultInstance() {
}

CCLCMsg_BaselineAck::CCLCMsg_BaselineAck(const CCLCMsg_BaselineAck& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:CCLCMsg_BaselineAck)
}

void CCLCMsg_BaselineAck::SharedCtor() {
  _cached_size_ = 0;
  baseline_tick_ = 0;
  baseline_nr_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CCLCMsg_BaselineAck::~CCLCMsg_BaselineAck() {
  // @@protoc_insertion_point(destructor:CCLCMsg_BaselineAck)
  SharedDtor();
}

void CCLCMsg_BaselineAck::SharedDtor() {
  if (this != default_instance_) {
  }
}

void CCLCMsg_BaselineAck::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CCLCMsg_BaselineAck::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return CCLCMsg_BaselineAck_descriptor_;
}

const CCLCMsg_BaselineAck& CCLCMsg_BaselineAck::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
  return *default_instance_;
}

CCLCMsg_BaselineAck* CCLCMsg_BaselineAck::default_instance_ = NULL;

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

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

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

  ZR_(baseline_tick_, baseline_nr_);

#undef OFFSET_OF_FIELD_
#undef ZR_

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

bool CCLCMsg_BaselineAck::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:CCLCMsg_BaselineAck)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 baseline_tick = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &baseline_tick_)));
          set_has_baseline_tick();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_baseline_nr;
        break;
      }

      // optional int32 baseline_nr = 2;
      case 2: {
        if (tag == 16) {
         parse_baseline_nr:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &baseline_nr_)));
          set_has_baseline_nr();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

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

void CCLCMsg_BaselineAck::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:CCLCMsg_BaselineAck)
  // optional int32 baseline_tick = 1;
  if (has_baseline_tick()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->baseline_tick(), output);
  }

  // optional int32 baseline_nr = 2;
  if (has_baseline_nr()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->baseline_nr(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:CCLCMsg_BaselineAck)
}

::google::protobuf::uint8* CCLCMsg_BaselineAck::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:CCLCMsg_BaselineAck)
  // optional int32 baseline_tick = 1;
  if (has_baseline_tick()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->baseline_tick(), target);
  }

  // optional int32 baseline_nr = 2;
  if (has_baseline_nr()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->baseline_nr(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:CCLCMsg_BaselineAck)
  return target;
}

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional int32 baseline_tick = 1;
    if (has_baseline_tick()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->baseline_tick());
    }

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

  }
  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 CCLCMsg_BaselineAck::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const CCLCMsg_BaselineAck* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const CCLCMsg_BaselineAck*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void CCLCMsg_BaselineAck::MergeFrom(const CCLCMsg_BaselineAck& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_baseline_tick()) {
      set_baseline_tick(from.baseline_tick());
    }
    if (from.has_baseline_nr()) {
      set_baseline_nr(from.baseline_nr());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void CCLCMsg_BaselineAck::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool CCLCMsg_BaselineAck::IsInitialized() const {

  return true;
}

void CCLCMsg_BaselineAck::Swap(CCLCMsg_BaselineAck* other) {
  if (other != this) {
    std::swap(baseline_tick_, other->baseline_tick_);
    std::swap(baseline_nr_, other->baseline_nr_);
    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 CCLCMsg_BaselineAck::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CCLCMsg_BaselineAck_descriptor_;
  metadata.reflection = CCLCMsg_BaselineAck_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int CCLCMsg_ListenEvents::kEventMaskFieldNumber;
#endif  // !_MSC_VER

CCLCMsg_ListenEvents::CCLCMsg_ListenEvents()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:CCLCMsg_ListenEvents)
}

void CCLCMsg_ListenEvents::InitAsDefaultInstance() {
}

CCLCMsg_ListenEvents::CCLCMsg_ListenEvents(const CCLCMsg_ListenEvents& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:CCLCMsg_ListenEvents)
}

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

CCLCMsg_ListenEvents::~CCLCMsg_ListenEvents() {
  // @@protoc_insertion_point(destructor:CCLCMsg_ListenEvents)
  SharedDtor();
}

void CCLCMsg_ListenEvents::SharedDtor() {
  if (this != default_instance_) {
  }
}

void CCLCMsg_ListenEvents::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CCLCMsg_ListenEvents::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return CCLCMsg_ListenEvents_descriptor_;
}

const CCLCMsg_ListenEvents& CCLCMsg_ListenEvents::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
  return *default_instance_;
}

CCLCMsg_ListenEvents* CCLCMsg_ListenEvents::default_instance_ = NULL;

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

void CCLCMsg_ListenEvents::Clear() {
  event_mask_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool CCLCMsg_ListenEvents::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:CCLCMsg_ListenEvents)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // repeated fixed32 event_mask = 1;
      case 1: {
        if (tag == 13) {
         parse_event_mask:
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
                 1, 13, input, this->mutable_event_mask())));
        } else if (tag == 10) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
                 input, this->mutable_event_mask())));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(13)) goto parse_event_mask;
        if (input->ExpectAtEnd()) goto success;
        break;
      }

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

void CCLCMsg_ListenEvents::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:CCLCMsg_ListenEvents)
  // repeated fixed32 event_mask = 1;
  for (int i = 0; i < this->event_mask_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteFixed32(
      1, this->event_mask(i), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:CCLCMsg_ListenEvents)
}

::google::protobuf::uint8* CCLCMsg_ListenEvents::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:CCLCMsg_ListenEvents)
  // repeated fixed32 event_mask = 1;
  for (int i = 0; i < this->event_mask_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteFixed32ToArray(1, this->event_mask(i), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:CCLCMsg_ListenEvents)
  return target;
}

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

  // repeated fixed32 event_mask = 1;
  {
    int data_size = 0;
    data_size = 4 * this->event_mask_size();
    total_size += 1 * this->event_mask_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 CCLCMsg_ListenEvents::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const CCLCMsg_ListenEvents* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const CCLCMsg_ListenEvents*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

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

void CCLCMsg_ListenEvents::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool CCLCMsg_ListenEvents::IsInitialized() const {

  return true;
}

void CCLCMsg_ListenEvents::Swap(CCLCMsg_ListenEvents* other) {
  if (other != this) {
    event_mask_.Swap(&other->event_mask_);
    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 CCLCMsg_ListenEvents::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CCLCMsg_ListenEvents_descriptor_;
  metadata.reflection = CCLCMsg_ListenEvents_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int CCLCMsg_RespondCvarValue::kCookieFieldNumber;
const int CCLCMsg_RespondCvarValue::kStatusCodeFieldNumber;
const int CCLCMsg_RespondCvarValue::kNameFieldNumber;
const int CCLCMsg_RespondCvarValue::kValueFieldNumber;
#endif  // !_MSC_VER

CCLCMsg_RespondCvarValue::CCLCMsg_RespondCvarValue()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:CCLCMsg_RespondCvarValue)
}

void CCLCMsg_RespondCvarValue::InitAsDefaultInstance() {
}

CCLCMsg_RespondCvarValue::CCLCMsg_RespondCvarValue(const CCLCMsg_RespondCvarValue& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:CCLCMsg_RespondCvarValue)
}

void CCLCMsg_RespondCvarValue::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  cookie_ = 0;
  status_code_ = 0;
  name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  value_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CCLCMsg_RespondCvarValue::~CCLCMsg_RespondCvarValue() {
  // @@protoc_insertion_point(destructor:CCLCMsg_RespondCvarValue)
  SharedDtor();
}

void CCLCMsg_RespondCvarValue::SharedDtor() {
  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete name_;
  }
  if (value_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete value_;
  }
  if (this != default_instance_) {
  }
}

void CCLCMsg_RespondCvarValue::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CCLCMsg_RespondCvarValue::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return CCLCMsg_RespondCvarValue_descriptor_;
}

const CCLCMsg_RespondCvarValue& CCLCMsg_RespondCvarValue::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
  return *default_instance_;
}

CCLCMsg_RespondCvarValue* CCLCMsg_RespondCvarValue::default_instance_ = NULL;

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

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

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

  if (_has_bits_[0 / 32] & 15) {
    ZR_(cookie_, status_code_);
    if (has_name()) {
      if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        name_->clear();
      }
    }
    if (has_value()) {
      if (value_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        value_->clear();
      }
    }
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

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

bool CCLCMsg_RespondCvarValue::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:CCLCMsg_RespondCvarValue)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 cookie = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &cookie_)));
          set_has_cookie();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_status_code;
        break;
      }

      // optional int32 status_code = 2;
      case 2: {
        if (tag == 16) {
         parse_status_code:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &status_code_)));
          set_has_status_code();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_name;
        break;
      }

      // optional string name = 3;
      case 3: {
        if (tag == 26) {
         parse_name:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_name()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->name().data(), this->name().length(),
            ::google::protobuf::internal::WireFormat::PARSE,
            "name");
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(34)) goto parse_value;
        break;
      }

      // optional string value = 4;
      case 4: {
        if (tag == 34) {
         parse_value:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_value()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->value().data(), this->value().length(),
            ::google::protobuf::internal::WireFormat::PARSE,
            "value");
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

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

void CCLCMsg_RespondCvarValue::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:CCLCMsg_RespondCvarValue)
  // optional int32 cookie = 1;
  if (has_cookie()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->cookie(), output);
  }

  // optional int32 status_code = 2;
  if (has_status_code()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->status_code(), output);
  }

  // optional string name = 3;
  if (has_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->name().data(), this->name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "name");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      3, this->name(), output);
  }

  // optional string value = 4;
  if (has_value()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->value().data(), this->value().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "value");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      4, this->value(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:CCLCMsg_RespondCvarValue)
}

::google::protobuf::uint8* CCLCMsg_RespondCvarValue::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:CCLCMsg_RespondCvarValue)
  // optional int32 cookie = 1;
  if (has_cookie()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->cookie(), target);
  }

  // optional int32 status_code = 2;
  if (has_status_code()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->status_code(), target);
  }

  // optional string name = 3;
  if (has_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->name().data(), this->name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "name");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        3, this->name(), target);
  }

  // optional string value = 4;
  if (has_value()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->value().data(), this->value().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "value");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        4, this->value(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:CCLCMsg_RespondCvarValue)
  return target;
}

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional int32 cookie = 1;
    if (has_cookie()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->cookie());
    }

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

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

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

  }
  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 CCLCMsg_RespondCvarValue::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const CCLCMsg_RespondCvarValue* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const CCLCMsg_RespondCvarValue*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void CCLCMsg_RespondCvarValue::MergeFrom(const CCLCMsg_RespondCvarValue& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_cookie()) {
      set_cookie(from.cookie());
    }
    if (from.has_status_code()) {
      set_status_code(from.status_code());
    }
    if (from.has_name()) {
      set_name(from.name());
    }
    if (from.has_value()) {
      set_value(from.value());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void CCLCMsg_RespondCvarValue::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool CCLCMsg_RespondCvarValue::IsInitialized() const {

  return true;
}

void CCLCMsg_RespondCvarValue::Swap(CCLCMsg_RespondCvarValue* other) {
  if (other != this) {
    std::swap(cookie_, other->cookie_);
    std::swap(status_code_, other->status_code_);
    std::swap(name_, other->name_);
    std::swap(value_, other->value_);
    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 CCLCMsg_RespondCvarValue::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CCLCMsg_RespondCvarValue_descriptor_;
  metadata.reflection = CCLCMsg_RespondCvarValue_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int CCLCMsg_FileCRCCheck::kCodePathFieldNumber;
const int CCLCMsg_FileCRCCheck::kPathFieldNumber;
const int CCLCMsg_FileCRCCheck::kCodeFilenameFieldNumber;
const int CCLCMsg_FileCRCCheck::kFilenameFieldNumber;
const int CCLCMsg_FileCRCCheck::kCrcFieldNumber;
#endif  // !_MSC_VER

CCLCMsg_FileCRCCheck::CCLCMsg_FileCRCCheck()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:CCLCMsg_FileCRCCheck)
}

void CCLCMsg_FileCRCCheck::InitAsDefaultInstance() {
}

CCLCMsg_FileCRCCheck::CCLCMsg_FileCRCCheck(const CCLCMsg_FileCRCCheck& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:CCLCMsg_FileCRCCheck)
}

void CCLCMsg_FileCRCCheck::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  code_path_ = 0;
  path_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  code_filename_ = 0;
  filename_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  crc_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CCLCMsg_FileCRCCheck::~CCLCMsg_FileCRCCheck() {
  // @@protoc_insertion_point(destructor:CCLCMsg_FileCRCCheck)
  SharedDtor();
}

void CCLCMsg_FileCRCCheck::SharedDtor() {
  if (path_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete path_;
  }
  if (filename_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete filename_;
  }
  if (this != default_instance_) {
  }
}

void CCLCMsg_FileCRCCheck::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CCLCMsg_FileCRCCheck::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return CCLCMsg_FileCRCCheck_descriptor_;
}

const CCLCMsg_FileCRCCheck& CCLCMsg_FileCRCCheck::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
  return *default_instance_;
}

CCLCMsg_FileCRCCheck* CCLCMsg_FileCRCCheck::default_instance_ = NULL;

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

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

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

  if (_has_bits_[0 / 32] & 31) {
    ZR_(code_path_, code_filename_);
    if (has_path()) {
      if (path_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        path_->clear();
      }
    }
    if (has_filename()) {
      if (filename_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        filename_->clear();
      }
    }
    crc_ = 0u;
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

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

bool CCLCMsg_FileCRCCheck::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:CCLCMsg_FileCRCCheck)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 code_path = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &code_path_)));
          set_has_code_path();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_path;
        break;
      }

      // optional string path = 2;
      case 2: {
        if (tag == 18) {
         parse_path:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_path()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->path().data(), this->path().length(),
            ::google::protobuf::internal::WireFormat::PARSE,
            "path");
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_code_filename;
        break;
      }

      // optional int32 code_filename = 3;
      case 3: {
        if (tag == 24) {
         parse_code_filename:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &code_filename_)));
          set_has_code_filename();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(34)) goto parse_filename;
        break;
      }

      // optional string filename = 4;
      case 4: {
        if (tag == 34) {
         parse_filename:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_filename()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->filename().data(), this->filename().length(),
            ::google::protobuf::internal::WireFormat::PARSE,
            "filename");
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(45)) goto parse_crc;
        break;
      }

      // optional fixed32 crc = 5;
      case 5: {
        if (tag == 45) {
         parse_crc:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
                 input, &crc_)));
          set_has_crc();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

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

void CCLCMsg_FileCRCCheck::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:CCLCMsg_FileCRCCheck)
  // optional int32 code_path = 1;
  if (has_code_path()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->code_path(), output);
  }

  // optional string path = 2;
  if (has_path()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->path().data(), this->path().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "path");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      2, this->path(), output);
  }

  // optional int32 code_filename = 3;
  if (has_code_filename()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->code_filename(), output);
  }

  // optional string filename = 4;
  if (has_filename()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->filename().data(), this->filename().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "filename");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      4, this->filename(), output);
  }

  // optional fixed32 crc = 5;
  if (has_crc()) {
    ::google::protobuf::internal::WireFormatLite::WriteFixed32(5, this->crc(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:CCLCMsg_FileCRCCheck)
}

::google::protobuf::uint8* CCLCMsg_FileCRCCheck::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:CCLCMsg_FileCRCCheck)
  // optional int32 code_path = 1;
  if (has_code_path()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->code_path(), target);
  }

  // optional string path = 2;
  if (has_path()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->path().data(), this->path().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "path");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        2, this->path(), target);
  }

  // optional int32 code_filename = 3;
  if (has_code_filename()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->code_filename(), target);
  }

  // optional string filename = 4;
  if (has_filename()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->filename().data(), this->filename().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "filename");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        4, this->filename(), target);
  }

  // optional fixed32 crc = 5;
  if (has_crc()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(5, this->crc(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:CCLCMsg_FileCRCCheck)
  return target;
}

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional int32 code_path = 1;
    if (has_code_path()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->code_path());
    }

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

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

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

    // optional fixed32 crc = 5;
    if (has_crc()) {
      total_size += 1 + 4;
    }

  }
  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 CCLCMsg_FileCRCCheck::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const CCLCMsg_FileCRCCheck* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const CCLCMsg_FileCRCCheck*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void CCLCMsg_FileCRCCheck::MergeFrom(const CCLCMsg_FileCRCCheck& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_code_path()) {
      set_code_path(from.code_path());
    }
    if (from.has_path()) {
      set_path(from.path());
    }
    if (from.has_code_filename()) {
      set_code_filename(from.code_filename());
    }
    if (from.has_filename()) {
      set_filename(from.filename());
    }
    if (from.has_crc()) {
      set_crc(from.crc());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void CCLCMsg_FileCRCCheck::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool CCLCMsg_FileCRCCheck::IsInitialized() const {

  return true;
}

void CCLCMsg_FileCRCCheck::Swap(CCLCMsg_FileCRCCheck* other) {
  if (other != this) {
    std::swap(code_path_, other->code_path_);
    std::swap(path_, other->path_);
    std::swap(code_filename_, other->code_filename_);
    std::swap(filename_, other->filename_);
    std::swap(crc_, other->crc_);
    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 CCLCMsg_FileCRCCheck::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CCLCMsg_FileCRCCheck_descriptor_;
  metadata.reflection = CCLCMsg_FileCRCCheck_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int CCLCMsg_LoadingProgress::kProgressFieldNumber;
#endif  // !_MSC_VER

CCLCMsg_LoadingProgress::CCLCMsg_LoadingProgress()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:CCLCMsg_LoadingProgress)
}

void CCLCMsg_LoadingProgress::InitAsDefaultInstance() {
}

CCLCMsg_LoadingProgress::CCLCMsg_LoadingProgress(const CCLCMsg_LoadingProgress& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:CCLCMsg_LoadingProgress)
}

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

CCLCMsg_LoadingProgress::~CCLCMsg_LoadingProgress() {
  // @@protoc_insertion_point(destructor:CCLCMsg_LoadingProgress)
  SharedDtor();
}

void CCLCMsg_LoadingProgress::SharedDtor() {
  if (this != default_instance_) {
  }
}

void CCLCMsg_LoadingProgress::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CCLCMsg_LoadingProgress::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return CCLCMsg_LoadingProgress_descriptor_;
}

const CCLCMsg_LoadingProgress& CCLCMsg_LoadingProgress::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
  return *default_instance_;
}

CCLCMsg_LoadingProgress* CCLCMsg_LoadingProgress::default_instance_ = NULL;

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

void CCLCMsg_LoadingProgress::Clear() {
  progress_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool CCLCMsg_LoadingProgress::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:CCLCMsg_LoadingProgress)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 progress = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &progress_)));
          set_has_progress();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

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

void CCLCMsg_LoadingProgress::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:CCLCMsg_LoadingProgress)
  // optional int32 progress = 1;
  if (has_progress()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->progress(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:CCLCMsg_LoadingProgress)
}

::google::protobuf::uint8* CCLCMsg_LoadingProgress::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:CCLCMsg_LoadingProgress)
  // optional int32 progress = 1;
  if (has_progress()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->progress(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:CCLCMsg_LoadingProgress)
  return target;
}

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional int32 progress = 1;
    if (has_progress()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->progress());
    }

  }
  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 CCLCMsg_LoadingProgress::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const CCLCMsg_LoadingProgress* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const CCLCMsg_LoadingProgress*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void CCLCMsg_LoadingProgress::MergeFrom(const CCLCMsg_LoadingProgress& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_progress()) {
      set_progress(from.progress());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void CCLCMsg_LoadingProgress::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool CCLCMsg_LoadingProgress::IsInitialized() const {

  return true;
}

void CCLCMsg_LoadingProgress::Swap(CCLCMsg_LoadingProgress* other) {
  if (other != this) {
    std::swap(progress_, other->progress_);
    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 CCLCMsg_LoadingProgress::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CCLCMsg_LoadingProgress_descriptor_;
  metadata.reflection = CCLCMsg_LoadingProgress_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int CCLCMsg_SplitPlayerConnect::kPlayernameFieldNumber;
#endif  // !_MSC_VER

CCLCMsg_SplitPlayerConnect::CCLCMsg_SplitPlayerConnect()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:CCLCMsg_SplitPlayerConnect)
}

void CCLCMsg_SplitPlayerConnect::InitAsDefaultInstance() {
}

CCLCMsg_SplitPlayerConnect::CCLCMsg_SplitPlayerConnect(const CCLCMsg_SplitPlayerConnect& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:CCLCMsg_SplitPlayerConnect)
}

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

CCLCMsg_SplitPlayerConnect::~CCLCMsg_SplitPlayerConnect() {
  // @@protoc_insertion_point(destructor:CCLCMsg_SplitPlayerConnect)
  SharedDtor();
}

void CCLCMsg_SplitPlayerConnect::SharedDtor() {
  if (playername_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete playername_;
  }
  if (this != default_instance_) {
  }
}

void CCLCMsg_SplitPlayerConnect::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CCLCMsg_SplitPlayerConnect::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return CCLCMsg_SplitPlayerConnect_descriptor_;
}

const CCLCMsg_SplitPlayerConnect& CCLCMsg_SplitPlayerConnect::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
  return *default_instance_;
}

CCLCMsg_SplitPlayerConnect* CCLCMsg_SplitPlayerConnect::default_instance_ = NULL;

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

void CCLCMsg_SplitPlayerConnect::Clear() {
  if (has_playername()) {
    if (playername_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
      playername_->clear();
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool CCLCMsg_SplitPlayerConnect::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:CCLCMsg_SplitPlayerConnect)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional string playername = 1;
      case 1: {
        if (tag == 10) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_playername()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->playername().data(), this->playername().length(),
            ::google::protobuf::internal::WireFormat::PARSE,
            "playername");
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

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

void CCLCMsg_SplitPlayerConnect::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:CCLCMsg_SplitPlayerConnect)
  // optional string playername = 1;
  if (has_playername()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->playername().data(), this->playername().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "playername");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->playername(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:CCLCMsg_SplitPlayerConnect)
}

::google::protobuf::uint8* CCLCMsg_SplitPlayerConnect::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:CCLCMsg_SplitPlayerConnect)
  // optional string playername = 1;
  if (has_playername()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->playername().data(), this->playername().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "playername");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        1, this->playername(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:CCLCMsg_SplitPlayerConnect)
  return target;
}

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

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

  }
  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 CCLCMsg_SplitPlayerConnect::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const CCLCMsg_SplitPlayerConnect* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const CCLCMsg_SplitPlayerConnect*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void CCLCMsg_SplitPlayerConnect::MergeFrom(const CCLCMsg_SplitPlayerConnect& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_playername()) {
      set_playername(from.playername());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void CCLCMsg_SplitPlayerConnect::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool CCLCMsg_SplitPlayerConnect::IsInitialized() const {

  return true;
}

void CCLCMsg_SplitPlayerConnect::Swap(CCLCMsg_SplitPlayerConnect* other) {
  if (other != this) {
    std::swap(playername_, other->playername_);
    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 CCLCMsg_SplitPlayerConnect::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CCLCMsg_SplitPlayerConnect_descriptor_;
  metadata.reflection = CCLCMsg_SplitPlayerConnect_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int CCLCMsg_ClientMessage::kMsgTypeFieldNumber;
const int CCLCMsg_ClientMessage::kDataFieldNumber;
#endif  // !_MSC_VER

CCLCMsg_ClientMessage::CCLCMsg_ClientMessage()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:CCLCMsg_ClientMessage)
}

void CCLCMsg_ClientMessage::InitAsDefaultInstance() {
}

CCLCMsg_ClientMessage::CCLCMsg_ClientMessage(const CCLCMsg_ClientMessage& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:CCLCMsg_ClientMessage)
}

void CCLCMsg_ClientMessage::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  msg_type_ = 0;
  data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CCLCMsg_ClientMessage::~CCLCMsg_ClientMessage() {
  // @@protoc_insertion_point(destructor:CCLCMsg_ClientMessage)
  SharedDtor();
}

void CCLCMsg_ClientMessage::SharedDtor() {
  if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete data_;
  }
  if (this != default_instance_) {
  }
}

void CCLCMsg_ClientMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CCLCMsg_ClientMessage::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return CCLCMsg_ClientMessage_descriptor_;
}

const CCLCMsg_ClientMessage& CCLCMsg_ClientMessage::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
  return *default_instance_;
}

CCLCMsg_ClientMessage* CCLCMsg_ClientMessage::default_instance_ = NULL;

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

void CCLCMsg_ClientMessage::Clear() {
  if (_has_bits_[0 / 32] & 3) {
    msg_type_ = 0;
    if (has_data()) {
      if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        data_->clear();
      }
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool CCLCMsg_ClientMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:CCLCMsg_ClientMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 msg_type = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &msg_type_)));
          set_has_msg_type();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_data;
        break;
      }

      // optional bytes data = 2;
      case 2: {
        if (tag == 18) {
         parse_data:
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_data()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

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

void CCLCMsg_ClientMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:CCLCMsg_ClientMessage)
  // optional int32 msg_type = 1;
  if (has_msg_type()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->msg_type(), output);
  }

  // optional bytes data = 2;
  if (has_data()) {
    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
      2, this->data(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:CCLCMsg_ClientMessage)
}

::google::protobuf::uint8* CCLCMsg_ClientMessage::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:CCLCMsg_ClientMessage)
  // optional int32 msg_type = 1;
  if (has_msg_type()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->msg_type(), target);
  }

  // optional bytes data = 2;
  if (has_data()) {
    target =
      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
        2, this->data(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:CCLCMsg_ClientMessage)
  return target;
}

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional int32 msg_type = 1;
    if (has_msg_type()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->msg_type());
    }

    // optional bytes data = 2;
    if (has_data()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->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 CCLCMsg_ClientMessage::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const CCLCMsg_ClientMessage* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const CCLCMsg_ClientMessage*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void CCLCMsg_ClientMessage::MergeFrom(const CCLCMsg_ClientMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_msg_type()) {
      set_msg_type(from.msg_type());
    }
    if (from.has_data()) {
      set_data(from.data());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void CCLCMsg_ClientMessage::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool CCLCMsg_ClientMessage::IsInitialized() const {

  return true;
}

void CCLCMsg_ClientMessage::Swap(CCLCMsg_ClientMessage* other) {
  if (other != this) {
    std::swap(msg_type_, other->msg_type_);
    std::swap(data_, other->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 CCLCMsg_ClientMessage::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CCLCMsg_ClientMessage_descriptor_;
  metadata.reflection = CCLCMsg_ClientMessage_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int CCLCMsg_SplitPlayerDisconnect::kSlotFieldNumber;
#endif  // !_MSC_VER

CCLCMsg_SplitPlayerDisconnect::CCLCMsg_SplitPlayerDisconnect()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:CCLCMsg_SplitPlayerDisconnect)
}

void CCLCMsg_SplitPlayerDisconnect::InitAsDefaultInstance() {
}

CCLCMsg_SplitPlayerDisconnect::CCLCMsg_SplitPlayerDisconnect(const CCLCMsg_SplitPlayerDisconnect& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:CCLCMsg_SplitPlayerDisconnect)
}

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

CCLCMsg_SplitPlayerDisconnect::~CCLCMsg_SplitPlayerDisconnect() {
  // @@protoc_insertion_point(destructor:CCLCMsg_SplitPlayerDisconnect)
  SharedDtor();
}

void CCLCMsg_SplitPlayerDisconnect::SharedDtor() {
  if (this != default_instance_) {
  }
}

void CCLCMsg_SplitPlayerDisconnect::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CCLCMsg_SplitPlayerDisconnect::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return CCLCMsg_SplitPlayerDisconnect_descriptor_;
}

const CCLCMsg_SplitPlayerDisconnect& CCLCMsg_SplitPlayerDisconnect::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
  return *default_instance_;
}

CCLCMsg_SplitPlayerDisconnect* CCLCMsg_SplitPlayerDisconnect::default_instance_ = NULL;

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

void CCLCMsg_SplitPlayerDisconnect::Clear() {
  slot_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool CCLCMsg_SplitPlayerDisconnect::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:CCLCMsg_SplitPlayerDisconnect)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 slot = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &slot_)));
          set_has_slot();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

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

void CCLCMsg_SplitPlayerDisconnect::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:CCLCMsg_SplitPlayerDisconnect)
  // optional int32 slot = 1;
  if (has_slot()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->slot(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:CCLCMsg_SplitPlayerDisconnect)
}

::google::protobuf::uint8* CCLCMsg_SplitPlayerDisconnect::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:CCLCMsg_SplitPlayerDisconnect)
  // optional int32 slot = 1;
  if (has_slot()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->slot(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:CCLCMsg_SplitPlayerDisconnect)
  return target;
}

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional int32 slot = 1;
    if (has_slot()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->slot());
    }

  }
  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 CCLCMsg_SplitPlayerDisconnect::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const CCLCMsg_SplitPlayerDisconnect* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const CCLCMsg_SplitPlayerDisconnect*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void CCLCMsg_SplitPlayerDisconnect::MergeFrom(const CCLCMsg_SplitPlayerDisconnect& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_slot()) {
      set_slot(from.slot());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void CCLCMsg_SplitPlayerDisconnect::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool CCLCMsg_SplitPlayerDisconnect::IsInitialized() const {

  return true;
}

void CCLCMsg_SplitPlayerDisconnect::Swap(CCLCMsg_SplitPlayerDisconnect* other) {
  if (other != this) {
    std::swap(slot_, other->slot_);
    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 CCLCMsg_SplitPlayerDisconnect::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CCLCMsg_SplitPlayerDisconnect_descriptor_;
  metadata.reflection = CCLCMsg_SplitPlayerDisconnect_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int CCLCMsg_ServerStatus::kSimplifiedFieldNumber;
#endif  // !_MSC_VER

CCLCMsg_ServerStatus::CCLCMsg_ServerStatus()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:CCLCMsg_ServerStatus)
}

void CCLCMsg_ServerStatus::InitAsDefaultInstance() {
}

CCLCMsg_ServerStatus::CCLCMsg_ServerStatus(const CCLCMsg_ServerStatus& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:CCLCMsg_ServerStatus)
}

void CCLCMsg_ServerStatus::SharedCtor() {
  _cached_size_ = 0;
  simplified_ = false;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CCLCMsg_ServerStatus::~CCLCMsg_ServerStatus() {
  // @@protoc_insertion_point(destructor:CCLCMsg_ServerStatus)
  SharedDtor();
}

void CCLCMsg_ServerStatus::SharedDtor() {
  if (this != default_instance_) {
  }
}

void CCLCMsg_ServerStatus::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CCLCMsg_ServerStatus::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return CCLCMsg_ServerStatus_descriptor_;
}

const CCLCMsg_ServerStatus& CCLCMsg_ServerStatus::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
  return *default_instance_;
}

CCLCMsg_ServerStatus* CCLCMsg_ServerStatus::default_instance_ = NULL;

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

void CCLCMsg_ServerStatus::Clear() {
  simplified_ = false;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool CCLCMsg_ServerStatus::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:CCLCMsg_ServerStatus)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional bool simplified = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &simplified_)));
          set_has_simplified();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

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

void CCLCMsg_ServerStatus::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:CCLCMsg_ServerStatus)
  // optional bool simplified = 1;
  if (has_simplified()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->simplified(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:CCLCMsg_ServerStatus)
}

::google::protobuf::uint8* CCLCMsg_ServerStatus::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:CCLCMsg_ServerStatus)
  // optional bool simplified = 1;
  if (has_simplified()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(1, this->simplified(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:CCLCMsg_ServerStatus)
  return target;
}

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional bool simplified = 1;
    if (has_simplified()) {
      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 CCLCMsg_ServerStatus::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const CCLCMsg_ServerStatus* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const CCLCMsg_ServerStatus*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void CCLCMsg_ServerStatus::MergeFrom(const CCLCMsg_ServerStatus& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_simplified()) {
      set_simplified(from.simplified());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void CCLCMsg_ServerStatus::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool CCLCMsg_ServerStatus::IsInitialized() const {

  return true;
}

void CCLCMsg_ServerStatus::Swap(CCLCMsg_ServerStatus* other) {
  if (other != this) {
    std::swap(simplified_, other->simplified_);
    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 CCLCMsg_ServerStatus::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CCLCMsg_ServerStatus_descriptor_;
  metadata.reflection = CCLCMsg_ServerStatus_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
#endif  // !_MSC_VER

CCLCMsg_ServerPing::CCLCMsg_ServerPing()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:CCLCMsg_ServerPing)
}

void CCLCMsg_ServerPing::InitAsDefaultInstance() {
}

CCLCMsg_ServerPing::CCLCMsg_ServerPing(const CCLCMsg_ServerPing& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:CCLCMsg_ServerPing)
}

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

CCLCMsg_ServerPing::~CCLCMsg_ServerPing() {
  // @@protoc_insertion_point(destructor:CCLCMsg_ServerPing)
  SharedDtor();
}

void CCLCMsg_ServerPing::SharedDtor() {
  if (this != default_instance_) {
  }
}

void CCLCMsg_ServerPing::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CCLCMsg_ServerPing::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return CCLCMsg_ServerPing_descriptor_;
}

const CCLCMsg_ServerPing& CCLCMsg_ServerPing::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
  return *default_instance_;
}

CCLCMsg_ServerPing* CCLCMsg_ServerPing::default_instance_ = NULL;

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

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

bool CCLCMsg_ServerPing::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:CCLCMsg_ServerPing)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
  handle_unusual:
    if (tag == 0 ||
        ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
        ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
      goto success;
    }
    DO_(::google::protobuf::internal::WireFormat::SkipField(
          input, tag, mutable_unknown_fields()));
  }
success:
  // @@protoc_insertion_point(parse_success:CCLCMsg_ServerPing)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:CCLCMsg_ServerPing)
  return false;
#undef DO_
}

void CCLCMsg_ServerPing::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:CCLCMsg_ServerPing)
  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:CCLCMsg_ServerPing)
}

::google::protobuf::uint8* CCLCMsg_ServerPing::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:CCLCMsg_ServerPing)
  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:CCLCMsg_ServerPing)
  return target;
}

int CCLCMsg_ServerPing::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 CCLCMsg_ServerPing::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const CCLCMsg_ServerPing* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const CCLCMsg_ServerPing*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

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

void CCLCMsg_ServerPing::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool CCLCMsg_ServerPing::IsInitialized() const {

  return true;
}

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

::google::protobuf::Metadata CCLCMsg_ServerPing::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CCLCMsg_ServerPing_descriptor_;
  metadata.reflection = CCLCMsg_ServerPing_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int CCLCMsg_RequestPause::kPauseTypeFieldNumber;
const int CCLCMsg_RequestPause::kPauseGroupFieldNumber;
#endif  // !_MSC_VER

CCLCMsg_RequestPause::CCLCMsg_RequestPause()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:CCLCMsg_RequestPause)
}

void CCLCMsg_RequestPause::InitAsDefaultInstance() {
}

CCLCMsg_RequestPause::CCLCMsg_RequestPause(const CCLCMsg_RequestPause& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:CCLCMsg_RequestPause)
}

void CCLCMsg_RequestPause::SharedCtor() {
  _cached_size_ = 0;
  pause_type_ = 0;
  pause_group_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CCLCMsg_RequestPause::~CCLCMsg_RequestPause() {
  // @@protoc_insertion_point(destructor:CCLCMsg_RequestPause)
  SharedDtor();
}

void CCLCMsg_RequestPause::SharedDtor() {
  if (this != default_instance_) {
  }
}

void CCLCMsg_RequestPause::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CCLCMsg_RequestPause::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return CCLCMsg_RequestPause_descriptor_;
}

const CCLCMsg_RequestPause& CCLCMsg_RequestPause::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
  return *default_instance_;
}

CCLCMsg_RequestPause* CCLCMsg_RequestPause::default_instance_ = NULL;

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

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

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

  ZR_(pause_type_, pause_group_);

#undef OFFSET_OF_FIELD_
#undef ZR_

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

bool CCLCMsg_RequestPause::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:CCLCMsg_RequestPause)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .RequestPause_t pause_type = 1 [default = RP_PAUSE];
      case 1: {
        if (tag == 8) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::RequestPause_t_IsValid(value)) {
            set_pause_type(static_cast< ::RequestPause_t >(value));
          } else {
            mutable_unknown_fields()->AddVarint(1, value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_pause_group;
        break;
      }

      // optional int32 pause_group = 2;
      case 2: {
        if (tag == 16) {
         parse_pause_group:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &pause_group_)));
          set_has_pause_group();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

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

void CCLCMsg_RequestPause::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:CCLCMsg_RequestPause)
  // optional .RequestPause_t pause_type = 1 [default = RP_PAUSE];
  if (has_pause_type()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->pause_type(), output);
  }

  // optional int32 pause_group = 2;
  if (has_pause_group()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->pause_group(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:CCLCMsg_RequestPause)
}

::google::protobuf::uint8* CCLCMsg_RequestPause::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:CCLCMsg_RequestPause)
  // optional .RequestPause_t pause_type = 1 [default = RP_PAUSE];
  if (has_pause_type()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->pause_type(), target);
  }

  // optional int32 pause_group = 2;
  if (has_pause_group()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->pause_group(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:CCLCMsg_RequestPause)
  return target;
}

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional .RequestPause_t pause_type = 1 [default = RP_PAUSE];
    if (has_pause_type()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->pause_type());
    }

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

  }
  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 CCLCMsg_RequestPause::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const CCLCMsg_RequestPause* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const CCLCMsg_RequestPause*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void CCLCMsg_RequestPause::MergeFrom(const CCLCMsg_RequestPause& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_pause_type()) {
      set_pause_type(from.pause_type());
    }
    if (from.has_pause_group()) {
      set_pause_group(from.pause_group());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void CCLCMsg_RequestPause::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool CCLCMsg_RequestPause::IsInitialized() const {

  return true;
}

void CCLCMsg_RequestPause::Swap(CCLCMsg_RequestPause* other) {
  if (other != this) {
    std::swap(pause_type_, other->pause_type_);
    std::swap(pause_group_, other->pause_group_);
    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 CCLCMsg_RequestPause::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CCLCMsg_RequestPause_descriptor_;
  metadata.reflection = CCLCMsg_RequestPause_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int CCLCMsg_CmdKeyValues::kDataFieldNumber;
#endif  // !_MSC_VER

CCLCMsg_CmdKeyValues::CCLCMsg_CmdKeyValues()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:CCLCMsg_CmdKeyValues)
}

void CCLCMsg_CmdKeyValues::InitAsDefaultInstance() {
}

CCLCMsg_CmdKeyValues::CCLCMsg_CmdKeyValues(const CCLCMsg_CmdKeyValues& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:CCLCMsg_CmdKeyValues)
}

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

CCLCMsg_CmdKeyValues::~CCLCMsg_CmdKeyValues() {
  // @@protoc_insertion_point(destructor:CCLCMsg_CmdKeyValues)
  SharedDtor();
}

void CCLCMsg_CmdKeyValues::SharedDtor() {
  if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete data_;
  }
  if (this != default_instance_) {
  }
}

void CCLCMsg_CmdKeyValues::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CCLCMsg_CmdKeyValues::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return CCLCMsg_CmdKeyValues_descriptor_;
}

const CCLCMsg_CmdKeyValues& CCLCMsg_CmdKeyValues::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
  return *default_instance_;
}

CCLCMsg_CmdKeyValues* CCLCMsg_CmdKeyValues::default_instance_ = NULL;

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

void CCLCMsg_CmdKeyValues::Clear() {
  if (has_data()) {
    if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
      data_->clear();
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool CCLCMsg_CmdKeyValues::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:CCLCMsg_CmdKeyValues)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional bytes data = 1;
      case 1: {
        if (tag == 10) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_data()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

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

void CCLCMsg_CmdKeyValues::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:CCLCMsg_CmdKeyValues)
  // optional bytes data = 1;
  if (has_data()) {
    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
      1, this->data(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:CCLCMsg_CmdKeyValues)
}

::google::protobuf::uint8* CCLCMsg_CmdKeyValues::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:CCLCMsg_CmdKeyValues)
  // optional bytes data = 1;
  if (has_data()) {
    target =
      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
        1, this->data(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:CCLCMsg_CmdKeyValues)
  return target;
}

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional bytes data = 1;
    if (has_data()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->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 CCLCMsg_CmdKeyValues::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const CCLCMsg_CmdKeyValues* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const CCLCMsg_CmdKeyValues*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void CCLCMsg_CmdKeyValues::MergeFrom(const CCLCMsg_CmdKeyValues& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_data()) {
      set_data(from.data());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void CCLCMsg_CmdKeyValues::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool CCLCMsg_CmdKeyValues::IsInitialized() const {

  return true;
}

void CCLCMsg_CmdKeyValues::Swap(CCLCMsg_CmdKeyValues* other) {
  if (other != this) {
    std::swap(data_, other->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 CCLCMsg_CmdKeyValues::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CCLCMsg_CmdKeyValues_descriptor_;
  metadata.reflection = CCLCMsg_CmdKeyValues_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int CSVCMsg_ServerInfo::kProtocolFieldNumber;
const int CSVCMsg_ServerInfo::kServerCountFieldNumber;
const int CSVCMsg_ServerInfo::kIsDedicatedFieldNumber;
const int CSVCMsg_ServerInfo::kIsHltvFieldNumber;
const int CSVCMsg_ServerInfo::kIsReplayFieldNumber;
const int CSVCMsg_ServerInfo::kCOsFieldNumber;
const int CSVCMsg_ServerInfo::kMapCrcFieldNumber;
const int CSVCMsg_ServerInfo::kClientCrcFieldNumber;
const int CSVCMsg_ServerInfo::kStringTableCrcFieldNumber;
const int CSVCMsg_ServerInfo::kMaxClientsFieldNumber;
const int CSVCMsg_ServerInfo::kMaxClassesFieldNumber;
const int CSVCMsg_ServerInfo::kPlayerSlotFieldNumber;
const int CSVCMsg_ServerInfo::kTickIntervalFieldNumber;
const int CSVCMsg_ServerInfo::kGameDirFieldNumber;
const int CSVCMsg_ServerInfo::kMapNameFieldNumber;
const int CSVCMsg_ServerInfo::kSkyNameFieldNumber;
const int CSVCMsg_ServerInfo::kHostNameFieldNumber;
const int CSVCMsg_ServerInfo::kAddonNameFieldNumber;
const int CSVCMsg_ServerInfo::kGameSessionConfigFieldNumber;
const int CSVCMsg_ServerInfo::kGameSessionManifestFieldNumber;
#endif  // !_MSC_VER

CSVCMsg_ServerInfo::CSVCMsg_ServerInfo()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:CSVCMsg_ServerInfo)
}

void CSVCMsg_ServerInfo::InitAsDefaultInstance() {
  game_session_config_ = const_cast< ::CSVCMsg_GameSessionConfiguration*>(&::CSVCMsg_GameSessionConfiguration::default_instance());
}

CSVCMsg_ServerInfo::CSVCMsg_ServerInfo(const CSVCMsg_ServerInfo& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:CSVCMsg_ServerInfo)
}

void CSVCMsg_ServerInfo::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  protocol_ = 0;
  server_count_ = 0;
  is_dedicated_ = false;
  is_hltv_ = false;
  is_replay_ = false;
  c_os_ = 0;
  map_crc_ = 0u;
  client_crc_ = 0u;
  string_table_crc_ = 0u;
  max_clients_ = 0;
  max_classes_ = 0;
  player_slot_ = 0;
  tick_interval_ = 0;
  game_dir_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  map_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  sky_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  host_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  addon_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  game_session_config_ = NULL;
  game_session_manifest_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CSVCMsg_ServerInfo::~CSVCMsg_ServerInfo() {
  // @@protoc_insertion_point(destructor:CSVCMsg_ServerInfo)
  SharedDtor();
}

void CSVCMsg_ServerInfo::SharedDtor() {
  if (game_dir_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete game_dir_;
  }
  if (map_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete map_name_;
  }
  if (sky_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete sky_name_;
  }
  if (host_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete host_name_;
  }
  if (addon_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete addon_name_;
  }
  if (game_session_manifest_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete game_session_manifest_;
  }
  if (this != default_instance_) {
    delete game_session_config_;
  }
}

void CSVCMsg_ServerInfo::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CSVCMsg_ServerInfo::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return CSVCMsg_ServerInfo_descriptor_;
}

const CSVCMsg_ServerInfo& CSVCMsg_ServerInfo::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
  return *default_instance_;
}

CSVCMsg_ServerInfo* CSVCMsg_ServerInfo::default_instance_ = NULL;

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

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

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

  if (_has_bits_[0 / 32] & 255) {
    ZR_(protocol_, client_crc_);
  }
  if (_has_bits_[8 / 32] & 65280) {
    ZR_(string_table_crc_, player_slot_);
    tick_interval_ = 0;
    if (has_game_dir()) {
      if (game_dir_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        game_dir_->clear();
      }
    }
    if (has_map_name()) {
      if (map_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        map_name_->clear();
      }
    }
    if (has_sky_name()) {
      if (sky_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        sky_name_->clear();
      }
    }
  }
  if (_has_bits_[16 / 32] & 983040) {
    if (has_host_name()) {
      if (host_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        host_name_->clear();
      }
    }
    if (has_addon_name()) {
      if (addon_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        addon_name_->clear();
      }
    }
    if (has_game_session_config()) {
      if (game_session_config_ != NULL) game_session_config_->::CSVCMsg_GameSessionConfiguration::Clear();
    }
    if (has_game_session_manifest()) {
      if (game_session_manifest_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        game_session_manifest_->clear();
      }
    }
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

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

bool CSVCMsg_ServerInfo::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:CSVCMsg_ServerInfo)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(16383);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 protocol = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &protocol_)));
          set_has_protocol();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_server_count;
        break;
      }

      // optional int32 server_count = 2;
      case 2: {
        if (tag == 16) {
         parse_server_count:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &server_count_)));
          set_has_server_count();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_is_dedicated;
        break;
      }

      // optional bool is_dedicated = 3;
      case 3: {
        if (tag == 24) {
         parse_is_dedicated:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &is_dedicated_)));
          set_has_is_dedicated();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(32)) goto parse_is_hltv;
        break;
      }

      // optional bool is_hltv = 4;
      case 4: {
        if (tag == 32) {
         parse_is_hltv:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &is_hltv_)));
          set_has_is_hltv();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(40)) goto parse_is_replay;
        break;
      }

      // optional bool is_replay = 5;
      case 5: {
        if (tag == 40) {
         parse_is_replay:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &is_replay_)));
          set_has_is_replay();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(48)) goto parse_c_os;
        break;
      }

      // optional int32 c_os = 6;
      case 6: {
        if (tag == 48) {
         parse_c_os:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &c_os_)));
          set_has_c_os();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(61)) goto parse_map_crc;
        break;
      }

      // optional fixed32 map_crc = 7;
      case 7: {
        if (tag == 61) {
         parse_map_crc:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
                 input, &map_crc_)));
          set_has_map_crc();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(69)) goto parse_client_crc;
        break;
      }

      // optional fixed32 client_crc = 8;
      case 8: {
        if (tag == 69) {
         parse_client_crc:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
                 input, &client_crc_)));
          set_has_client_crc();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(77)) goto parse_string_table_crc;
        break;
      }

      // optional fixed32 string_table_crc = 9;
      case 9: {
        if (tag == 77) {
         parse_string_table_crc:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
                 input, &string_table_crc_)));
          set_has_string_table_crc();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(80)) goto parse_max_clients;
        break;
      }

      // optional int32 max_clients = 10;
      case 10: {
        if (tag == 80) {
         parse_max_clients:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &max_clients_)));
          set_has_max_clients();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(88)) goto parse_max_classes;
        break;
      }

      // optional int32 max_classes = 11;
      case 11: {
        if (tag == 88) {
         parse_max_classes:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &max_classes_)));
          set_has_max_classes();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(96)) goto parse_player_slot;
        break;
      }

      // optional int32 player_slot = 12;
      case 12: {
        if (tag == 96) {
         parse_player_slot:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &player_slot_)));
          set_has_player_slot();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(109)) goto parse_tick_interval;
        break;
      }

      // optional float tick_interval = 13;
      case 13: {
        if (tag == 109) {
         parse_tick_interval:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &tick_interval_)));
          set_has_tick_interval();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(114)) goto parse_game_dir;
        break;
      }

      // optional string game_dir = 14;
      case 14: {
        if (tag == 114) {
         parse_game_dir:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_game_dir()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->game_dir().data(), this->game_dir().length(),
            ::google::protobuf::internal::WireFormat::PARSE,
            "game_dir");
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(122)) goto parse_map_name;
        break;
      }

      // optional string map_name = 15;
      case 15: {
        if (tag == 122) {
         parse_map_name:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_map_name()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->map_name().data(), this->map_name().length(),
            ::google::protobuf::internal::WireFormat::PARSE,
            "map_name");
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(130)) goto parse_sky_name;
        break;
      }

      // optional string sky_name = 16;
      case 16: {
        if (tag == 130) {
         parse_sky_name:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_sky_name()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->sky_name().data(), this->sky_name().length(),
            ::google::protobuf::internal::WireFormat::PARSE,
            "sky_name");
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(138)) goto parse_host_name;
        break;
      }

      // optional string host_name = 17;
      case 17: {
        if (tag == 138) {
         parse_host_name:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_host_name()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->host_name().data(), this->host_name().length(),
            ::google::protobuf::internal::WireFormat::PARSE,
            "host_name");
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(146)) goto parse_addon_name;
        break;
      }

      // optional string addon_name = 18;
      case 18: {
        if (tag == 146) {
         parse_addon_name:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_addon_name()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->addon_name().data(), this->addon_name().length(),
            ::google::protobuf::internal::WireFormat::PARSE,
            "addon_name");
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(154)) goto parse_game_session_config;
        break;
      }

      // optional .CSVCMsg_GameSessionConfiguration game_session_config = 19;
      case 19: {
        if (tag == 154) {
         parse_game_session_config:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_game_session_config()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(162)) goto parse_game_session_manifest;
        break;
      }

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

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

void CSVCMsg_ServerInfo::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:CSVCMsg_ServerInfo)
  // optional int32 protocol = 1;
  if (has_protocol()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->protocol(), output);
  }

  // optional int32 server_count = 2;
  if (has_server_count()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->server_count(), output);
  }

  // optional bool is_dedicated = 3;
  if (has_is_dedicated()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->is_dedicated(), output);
  }

  // optional bool is_hltv = 4;
  if (has_is_hltv()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->is_hltv(), output);
  }

  // optional bool is_replay = 5;
  if (has_is_replay()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(5, this->is_replay(), output);
  }

  // optional int32 c_os = 6;
  if (has_c_os()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(6, this->c_os(), output);
  }

  // optional fixed32 map_crc = 7;
  if (has_map_crc()) {
    ::google::protobuf::internal::WireFormatLite::WriteFixed32(7, this->map_crc(), output);
  }

  // optional fixed32 client_crc = 8;
  if (has_client_crc()) {
    ::google::protobuf::internal::WireFormatLite::WriteFixed32(8, this->client_crc(), output);
  }

  // optional fixed32 string_table_crc = 9;
  if (has_string_table_crc()) {
    ::google::protobuf::internal::WireFormatLite::WriteFixed32(9, this->string_table_crc(), output);
  }

  // optional int32 max_clients = 10;
  if (has_max_clients()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(10, this->max_clients(), output);
  }

  // optional int32 max_classes = 11;
  if (has_max_classes()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(11, this->max_classes(), output);
  }

  // optional int32 player_slot = 12;
  if (has_player_slot()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(12, this->player_slot(), output);
  }

  // optional float tick_interval = 13;
  if (has_tick_interval()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(13, this->tick_interval(), output);
  }

  // optional string game_dir = 14;
  if (has_game_dir()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->game_dir().data(), this->game_dir().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "game_dir");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      14, this->game_dir(), output);
  }

  // optional string map_name = 15;
  if (has_map_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->map_name().data(), this->map_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "map_name");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      15, this->map_name(), output);
  }

  // optional string sky_name = 16;
  if (has_sky_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->sky_name().data(), this->sky_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "sky_name");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      16, this->sky_name(), output);
  }

  // optional string host_name = 17;
  if (has_host_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->host_name().data(), this->host_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "host_name");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      17, this->host_name(), output);
  }

  // optional string addon_name = 18;
  if (has_addon_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->addon_name().data(), this->addon_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "addon_name");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      18, this->addon_name(), output);
  }

  // optional .CSVCMsg_GameSessionConfiguration game_session_config = 19;
  if (has_game_session_config()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      19, this->game_session_config(), output);
  }

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

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:CSVCMsg_ServerInfo)
}

::google::protobuf::uint8* CSVCMsg_ServerInfo::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:CSVCMsg_ServerInfo)
  // optional int32 protocol = 1;
  if (has_protocol()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->protocol(), target);
  }

  // optional int32 server_count = 2;
  if (has_server_count()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->server_count(), target);
  }

  // optional bool is_dedicated = 3;
  if (has_is_dedicated()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->is_dedicated(), target);
  }

  // optional bool is_hltv = 4;
  if (has_is_hltv()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(4, this->is_hltv(), target);
  }

  // optional bool is_replay = 5;
  if (has_is_replay()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(5, this->is_replay(), target);
  }

  // optional int32 c_os = 6;
  if (has_c_os()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(6, this->c_os(), target);
  }

  // optional fixed32 map_crc = 7;
  if (has_map_crc()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(7, this->map_crc(), target);
  }

  // optional fixed32 client_crc = 8;
  if (has_client_crc()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(8, this->client_crc(), target);
  }

  // optional fixed32 string_table_crc = 9;
  if (has_string_table_crc()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(9, this->string_table_crc(), target);
  }

  // optional int32 max_clients = 10;
  if (has_max_clients()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(10, this->max_clients(), target);
  }

  // optional int32 max_classes = 11;
  if (has_max_classes()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(11, this->max_classes(), target);
  }

  // optional int32 player_slot = 12;
  if (has_player_slot()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(12, this->player_slot(), target);
  }

  // optional float tick_interval = 13;
  if (has_tick_interval()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(13, this->tick_interval(), target);
  }

  // optional string game_dir = 14;
  if (has_game_dir()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->game_dir().data(), this->game_dir().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "game_dir");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        14, this->game_dir(), target);
  }

  // optional string map_name = 15;
  if (has_map_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->map_name().data(), this->map_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "map_name");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        15, this->map_name(), target);
  }

  // optional string sky_name = 16;
  if (has_sky_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->sky_name().data(), this->sky_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "sky_name");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        16, this->sky_name(), target);
  }

  // optional string host_name = 17;
  if (has_host_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->host_name().data(), this->host_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "host_name");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        17, this->host_name(), target);
  }

  // optional string addon_name = 18;
  if (has_addon_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->addon_name().data(), this->addon_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "addon_name");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        18, this->addon_name(), target);
  }

  // optional .CSVCMsg_GameSessionConfiguration game_session_config = 19;
  if (has_game_session_config()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        19, this->game_session_config(), target);
  }

  // optional bytes game_session_manifest = 20;
  if (has_game_session_manifest()) {
    target =
      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
        20, this->game_session_manifest(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:CSVCMsg_ServerInfo)
  return target;
}

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional int32 protocol = 1;
    if (has_protocol()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->protocol());
    }

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

    // optional bool is_dedicated = 3;
    if (has_is_dedicated()) {
      total_size += 1 + 1;
    }

    // optional bool is_hltv = 4;
    if (has_is_hltv()) {
      total_size += 1 + 1;
    }

    // optional bool is_replay = 5;
    if (has_is_replay()) {
      total_size += 1 + 1;
    }

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

    // optional fixed32 map_crc = 7;
    if (has_map_crc()) {
      total_size += 1 + 4;
    }

    // optional fixed32 client_crc = 8;
    if (has_client_crc()) {
      total_size += 1 + 4;
    }

  }
  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
    // optional fixed32 string_table_crc = 9;
    if (has_string_table_crc()) {
      total_size += 1 + 4;
    }

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

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

    // optional int32 player_slot = 12;
    if (has_player_slot()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->player_slot());
    }

    // optional float tick_interval = 13;
    if (has_tick_interval()) {
      total_size += 1 + 4;
    }

    // optional string game_dir = 14;
    if (has_game_dir()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->game_dir());
    }

    // optional string map_name = 15;
    if (has_map_name()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->map_name());
    }

    // optional string sky_name = 16;
    if (has_sky_name()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->sky_name());
    }

  }
  if (_has_bits_[16 / 32] & (0xffu << (16 % 32))) {
    // optional string host_name = 17;
    if (has_host_name()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->host_name());
    }

    // optional string addon_name = 18;
    if (has_addon_name()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->addon_name());
    }

    // optional .CSVCMsg_GameSessionConfiguration game_session_config = 19;
    if (has_game_session_config()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->game_session_config());
    }

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

  }
  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 CSVCMsg_ServerInfo::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const CSVCMsg_ServerInfo* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const CSVCMsg_ServerInfo*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void CSVCMsg_ServerInfo::MergeFrom(const CSVCMsg_ServerInfo& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_protocol()) {
      set_protocol(from.protocol());
    }
    if (from.has_server_count()) {
      set_server_count(from.server_count());
    }
    if (from.has_is_dedicated()) {
      set_is_dedicated(from.is_dedicated());
    }
    if (from.has_is_hltv()) {
      set_is_hltv(from.is_hltv());
    }
    if (from.has_is_replay()) {
      set_is_replay(from.is_replay());
    }
    if (from.has_c_os()) {
      set_c_os(from.c_os());
    }
    if (from.has_map_crc()) {
      set_map_crc(from.map_crc());
    }
    if (from.has_client_crc()) {
      set_client_crc(from.client_crc());
    }
  }
  if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
    if (from.has_string_table_crc()) {
      set_string_table_crc(from.string_table_crc());
    }
    if (from.has_max_clients()) {
      set_max_clients(from.max_clients());
    }
    if (from.has_max_classes()) {
      set_max_classes(from.max_classes());
    }
    if (from.has_player_slot()) {
      set_player_slot(from.player_slot());
    }
    if (from.has_tick_interval()) {
      set_tick_interval(from.tick_interval());
    }
    if (from.has_game_dir()) {
      set_game_dir(from.game_dir());
    }
    if (from.has_map_name()) {
      set_map_name(from.map_name());
    }
    if (from.has_sky_name()) {
      set_sky_name(from.sky_name());
    }
  }
  if (from._has_bits_[16 / 32] & (0xffu << (16 % 32))) {
    if (from.has_host_name()) {
      set_host_name(from.host_name());
    }
    if (from.has_addon_name()) {
      set_addon_name(from.addon_name());
    }
    if (from.has_game_session_config()) {
      mutable_game_session_config()->::CSVCMsg_GameSessionConfiguration::MergeFrom(from.game_session_config());
    }
    if (from.has_game_session_manifest()) {
      set_game_session_manifest(from.game_session_manifest());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void CSVCMsg_ServerInfo::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool CSVCMsg_ServerInfo::IsInitialized() const {

  return true;
}

void CSVCMsg_ServerInfo::Swap(CSVCMsg_ServerInfo* other) {
  if (other != this) {
    std::swap(protocol_, other->protocol_);
    std::swap(server_count_, other->server_count_);
    std::swap(is_dedicated_, other->is_dedicated_);
    std::swap(is_hltv_, other->is_hltv_);
    std::swap(is_replay_, other->is_replay_);
    std::swap(c_os_, other->c_os_);
    std::swap(map_crc_, other->map_crc_);
    std::swap(client_crc_, other->client_crc_);
    std::swap(string_table_crc_, other->string_table_crc_);
    std::swap(max_clients_, other->max_clients_);
    std::swap(max_classes_, other->max_classes_);
    std::swap(player_slot_, other->player_slot_);
    std::swap(tick_interval_, other->tick_interval_);
    std::swap(game_dir_, other->game_dir_);
    std::swap(map_name_, other->map_name_);
    std::swap(sky_name_, other->sky_name_);
    std::swap(host_name_, other->host_name_);
    std::swap(addon_name_, other->addon_name_);
    std::swap(game_session_config_, other->game_session_config_);
    std::swap(game_session_manifest_, other->game_session_manifest_);
    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 CSVCMsg_ServerInfo::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CSVCMsg_ServerInfo_descriptor_;
  metadata.reflection = CSVCMsg_ServerInfo_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int CSVCMsg_ClassInfo_class_t::kClassIdFieldNumber;
const int CSVCMsg_ClassInfo_class_t::kDataTableNameFieldNumber;
const int CSVCMsg_ClassInfo_class_t::kClassNameFieldNumber;
#endif  // !_MSC_VER

CSVCMsg_ClassInfo_class_t::CSVCMsg_ClassInfo_class_t()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:CSVCMsg_ClassInfo.class_t)
}

void CSVCMsg_ClassInfo_class_t::InitAsDefaultInstance() {
}

CSVCMsg_ClassInfo_class_t::CSVCMsg_ClassInfo_class_t(const CSVCMsg_ClassInfo_class_t& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:CSVCMsg_ClassInfo.class_t)
}

void CSVCMsg_ClassInfo_class_t::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  class_id_ = 0;
  data_table_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  class_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CSVCMsg_ClassInfo_class_t::~CSVCMsg_ClassInfo_class_t() {
  // @@protoc_insertion_point(destructor:CSVCMsg_ClassInfo.class_t)
  SharedDtor();
}

void CSVCMsg_ClassInfo_class_t::SharedDtor() {
  if (data_table_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete data_table_name_;
  }
  if (class_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete class_name_;
  }
  if (this != default_instance_) {
  }
}

void CSVCMsg_ClassInfo_class_t::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CSVCMsg_ClassInfo_class_t::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return CSVCMsg_ClassInfo_class_t_descriptor_;
}

const CSVCMsg_ClassInfo_class_t& CSVCMsg_ClassInfo_class_t::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
  return *default_instance_;
}

CSVCMsg_ClassInfo_class_t* CSVCMsg_ClassInfo_class_t::default_instance_ = NULL;

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

void CSVCMsg_ClassInfo_class_t::Clear() {
  if (_has_bits_[0 / 32] & 7) {
    class_id_ = 0;
    if (has_data_table_name()) {
      if (data_table_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        data_table_name_->clear();
      }
    }
    if (has_class_name()) {
      if (class_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        class_name_->clear();
      }
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool CSVCMsg_ClassInfo_class_t::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:CSVCMsg_ClassInfo.class_t)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 class_id = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &class_id_)));
          set_has_class_id();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_data_table_name;
        break;
      }

      // optional string data_table_name = 2;
      case 2: {
        if (tag == 18) {
         parse_data_table_name:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_data_table_name()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->data_table_name().data(), this->data_table_name().length(),
            ::google::protobuf::internal::WireFormat::PARSE,
            "data_table_name");
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_class_name;
        break;
      }

      // optional string class_name = 3;
      case 3: {
        if (tag == 26) {
         parse_class_name:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_class_name()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->class_name().data(), this->class_name().length(),
            ::google::protobuf::internal::WireFormat::PARSE,
            "class_name");
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

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

void CSVCMsg_ClassInfo_class_t::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:CSVCMsg_ClassInfo.class_t)
  // optional int32 class_id = 1;
  if (has_class_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->class_id(), output);
  }

  // optional string data_table_name = 2;
  if (has_data_table_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->data_table_name().data(), this->data_table_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "data_table_name");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      2, this->data_table_name(), output);
  }

  // optional string class_name = 3;
  if (has_class_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->class_name().data(), this->class_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "class_name");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      3, this->class_name(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:CSVCMsg_ClassInfo.class_t)
}

::google::protobuf::uint8* CSVCMsg_ClassInfo_class_t::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:CSVCMsg_ClassInfo.class_t)
  // optional int32 class_id = 1;
  if (has_class_id()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->class_id(), target);
  }

  // optional string data_table_name = 2;
  if (has_data_table_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->data_table_name().data(), this->data_table_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "data_table_name");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        2, this->data_table_name(), target);
  }

  // optional string class_name = 3;
  if (has_class_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->class_name().data(), this->class_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "class_name");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        3, this->class_name(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:CSVCMsg_ClassInfo.class_t)
  return target;
}

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional int32 class_id = 1;
    if (has_class_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->class_id());
    }

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

    // optional string class_name = 3;
    if (has_class_name()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->class_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 CSVCMsg_ClassInfo_class_t::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const CSVCMsg_ClassInfo_class_t* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const CSVCMsg_ClassInfo_class_t*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void CSVCMsg_ClassInfo_class_t::MergeFrom(const CSVCMsg_ClassInfo_class_t& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_class_id()) {
      set_class_id(from.class_id());
    }
    if (from.has_data_table_name()) {
      set_data_table_name(from.data_table_name());
    }
    if (from.has_class_name()) {
      set_class_name(from.class_name());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void CSVCMsg_ClassInfo_class_t::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool CSVCMsg_ClassInfo_class_t::IsInitialized() const {

  return true;
}

void CSVCMsg_ClassInfo_class_t::Swap(CSVCMsg_ClassInfo_class_t* other) {
  if (other != this) {
    std::swap(class_id_, other->class_id_);
    std::swap(data_table_name_, other->data_table_name_);
    std::swap(class_name_, other->class_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 CSVCMsg_ClassInfo_class_t::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CSVCMsg_ClassInfo_class_t_descriptor_;
  metadata.reflection = CSVCMsg_ClassInfo_class_t_reflection_;
  return metadata;
}


// -------------------------------------------------------------------

#ifndef _MSC_VER
const int CSVCMsg_ClassInfo::kCreateOnClientFieldNumber;
const int CSVCMsg_ClassInfo::kClassesFieldNumber;
#endif  // !_MSC_VER

CSVCMsg_ClassInfo::CSVCMsg_ClassInfo()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:CSVCMsg_ClassInfo)
}

void CSVCMsg_ClassInfo::InitAsDefaultInstance() {
}

CSVCMsg_ClassInfo::CSVCMsg_ClassInfo(const CSVCMsg_ClassInfo& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:CSVCMsg_ClassInfo)
}

void CSVCMsg_ClassInfo::SharedCtor() {
  _cached_size_ = 0;
  create_on_client_ = false;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CSVCMsg_ClassInfo::~CSVCMsg_ClassInfo() {
  // @@protoc_insertion_point(destructor:CSVCMsg_ClassInfo)
  SharedDtor();
}

void CSVCMsg_ClassInfo::SharedDtor() {
  if (this != default_instance_) {
  }
}

void CSVCMsg_ClassInfo::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CSVCMsg_ClassInfo::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return CSVCMsg_ClassInfo_descriptor_;
}

const CSVCMsg_ClassInfo& CSVCMsg_ClassInfo::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
  return *default_instance_;
}

CSVCMsg_ClassInfo* CSVCMsg_ClassInfo::default_instance_ = NULL;

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

void CSVCMsg_ClassInfo::Clear() {
  create_on_client_ = false;
  classes_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool CSVCMsg_ClassInfo::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:CSVCMsg_ClassInfo)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional bool create_on_client = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &create_on_client_)));
          set_has_create_on_client();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_classes;
        break;
      }

      // repeated .CSVCMsg_ClassInfo.class_t classes = 2;
      case 2: {
        if (tag == 18) {
         parse_classes:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_classes()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_classes;
        if (input->ExpectAtEnd()) goto success;
        break;
      }

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

void CSVCMsg_ClassInfo::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:CSVCMsg_ClassInfo)
  // optional bool create_on_client = 1;
  if (has_create_on_client()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->create_on_client(), output);
  }

  // repeated .CSVCMsg_ClassInfo.class_t classes = 2;
  for (int i = 0; i < this->classes_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      2, this->classes(i), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:CSVCMsg_ClassInfo)
}

::google::protobuf::uint8* CSVCMsg_ClassInfo::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:CSVCMsg_ClassInfo)
  // optional bool create_on_client = 1;
  if (has_create_on_client()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(1, this->create_on_client(), target);
  }

  // repeated .CSVCMsg_ClassInfo.class_t classes = 2;
  for (int i = 0; i < this->classes_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        2, this->classes(i), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:CSVCMsg_ClassInfo)
  return target;
}

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional bool create_on_client = 1;
    if (has_create_on_client()) {
      total_size += 1 + 1;
    }

  }
  // repeated .CSVCMsg_ClassInfo.class_t classes = 2;
  total_size += 1 * this->classes_size();
  for (int i = 0; i < this->classes_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->classes(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 CSVCMsg_ClassInfo::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const CSVCMsg_ClassInfo* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const CSVCMsg_ClassInfo*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void CSVCMsg_ClassInfo::MergeFrom(const CSVCMsg_ClassInfo& from) {
  GOOGLE_CHECK_NE(&from, this);
  classes_.MergeFrom(from.classes_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_create_on_client()) {
      set_create_on_client(from.create_on_client());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void CSVCMsg_ClassInfo::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool CSVCMsg_ClassInfo::IsInitialized() const {

  return true;
}

void CSVCMsg_ClassInfo::Swap(CSVCMsg_ClassInfo* other) {
  if (other != this) {
    std::swap(create_on_client_, other->create_on_client_);
    classes_.Swap(&other->classes_);
    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 CSVCMsg_ClassInfo::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CSVCMsg_ClassInfo_descriptor_;
  metadata.reflection = CSVCMsg_ClassInfo_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int CSVCMsg_SetPause::kPausedFieldNumber;
#endif  // !_MSC_VER

CSVCMsg_SetPause::CSVCMsg_SetPause()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:CSVCMsg_SetPause)
}

void CSVCMsg_SetPause::InitAsDefaultInstance() {
}

CSVCMsg_SetPause::CSVCMsg_SetPause(const CSVCMsg_SetPause& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:CSVCMsg_SetPause)
}

void CSVCMsg_SetPause::SharedCtor() {
  _cached_size_ = 0;
  paused_ = false;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CSVCMsg_SetPause::~CSVCMsg_SetPause() {
  // @@protoc_insertion_point(destructor:CSVCMsg_SetPause)
  SharedDtor();
}

void CSVCMsg_SetPause::SharedDtor() {
  if (this != default_instance_) {
  }
}

void CSVCMsg_SetPause::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CSVCMsg_SetPause::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return CSVCMsg_SetPause_descriptor_;
}

const CSVCMsg_SetPause& CSVCMsg_SetPause::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
  return *default_instance_;
}

CSVCMsg_SetPause* CSVCMsg_SetPause::default_instance_ = NULL;

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

void CSVCMsg_SetPause::Clear() {
  paused_ = false;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool CSVCMsg_SetPause::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:CSVCMsg_SetPause)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional bool paused = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &paused_)));
          set_has_paused();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

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

void CSVCMsg_SetPause::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:CSVCMsg_SetPause)
  // optional bool paused = 1;
  if (has_paused()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->paused(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:CSVCMsg_SetPause)
}

::google::protobuf::uint8* CSVCMsg_SetPause::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:CSVCMsg_SetPause)
  // optional bool paused = 1;
  if (has_paused()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(1, this->paused(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:CSVCMsg_SetPause)
  return target;
}

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional bool paused = 1;
    if (has_paused()) {
      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 CSVCMsg_SetPause::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const CSVCMsg_SetPause* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const CSVCMsg_SetPause*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void CSVCMsg_SetPause::MergeFrom(const CSVCMsg_SetPause& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_paused()) {
      set_paused(from.paused());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void CSVCMsg_SetPause::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool CSVCMsg_SetPause::IsInitialized() const {

  return true;
}

void CSVCMsg_SetPause::Swap(CSVCMsg_SetPause* other) {
  if (other != this) {
    std::swap(paused_, other->paused_);
    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 CSVCMsg_SetPause::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CSVCMsg_SetPause_descriptor_;
  metadata.reflection = CSVCMsg_SetPause_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int CSVCMsg_VoiceInit::kQualityFieldNumber;
const int CSVCMsg_VoiceInit::kCodecFieldNumber;
const int CSVCMsg_VoiceInit::kVersionFieldNumber;
#endif  // !_MSC_VER

CSVCMsg_VoiceInit::CSVCMsg_VoiceInit()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:CSVCMsg_VoiceInit)
}

void CSVCMsg_VoiceInit::InitAsDefaultInstance() {
}

CSVCMsg_VoiceInit::CSVCMsg_VoiceInit(const CSVCMsg_VoiceInit& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:CSVCMsg_VoiceInit)
}

void CSVCMsg_VoiceInit::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  quality_ = 0;
  codec_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  version_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CSVCMsg_VoiceInit::~CSVCMsg_VoiceInit() {
  // @@protoc_insertion_point(destructor:CSVCMsg_VoiceInit)
  SharedDtor();
}

void CSVCMsg_VoiceInit::SharedDtor() {
  if (codec_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete codec_;
  }
  if (this != default_instance_) {
  }
}

void CSVCMsg_VoiceInit::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CSVCMsg_VoiceInit::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return CSVCMsg_VoiceInit_descriptor_;
}

const CSVCMsg_VoiceInit& CSVCMsg_VoiceInit::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
  return *default_instance_;
}

CSVCMsg_VoiceInit* CSVCMsg_VoiceInit::default_instance_ = NULL;

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

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

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

  if (_has_bits_[0 / 32] & 7) {
    ZR_(quality_, version_);
    if (has_codec()) {
      if (codec_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        codec_->clear();
      }
    }
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

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

bool CSVCMsg_VoiceInit::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:CSVCMsg_VoiceInit)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 quality = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &quality_)));
          set_has_quality();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_codec;
        break;
      }

      // optional string codec = 2;
      case 2: {
        if (tag == 18) {
         parse_codec:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_codec()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->codec().data(), this->codec().length(),
            ::google::protobuf::internal::WireFormat::PARSE,
            "codec");
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_version;
        break;
      }

      // optional int32 version = 3 [default = 0];
      case 3: {
        if (tag == 24) {
         parse_version:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &version_)));
          set_has_version();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

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

void CSVCMsg_VoiceInit::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:CSVCMsg_VoiceInit)
  // optional int32 quality = 1;
  if (has_quality()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->quality(), output);
  }

  // optional string codec = 2;
  if (has_codec()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->codec().data(), this->codec().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "codec");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      2, this->codec(), output);
  }

  // optional int32 version = 3 [default = 0];
  if (has_version()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->version(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:CSVCMsg_VoiceInit)
}

::google::protobuf::uint8* CSVCMsg_VoiceInit::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:CSVCMsg_VoiceInit)
  // optional int32 quality = 1;
  if (has_quality()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->quality(), target);
  }

  // optional string codec = 2;
  if (has_codec()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->codec().data(), this->codec().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "codec");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        2, this->codec(), target);
  }

  // optional int32 version = 3 [default = 0];
  if (has_version()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->version(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:CSVCMsg_VoiceInit)
  return target;
}

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional int32 quality = 1;
    if (has_quality()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->quality());
    }

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

    // optional int32 version = 3 [default = 0];
    if (has_version()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          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 CSVCMsg_VoiceInit::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const CSVCMsg_VoiceInit* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const CSVCMsg_VoiceInit*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void CSVCMsg_VoiceInit::MergeFrom(const CSVCMsg_VoiceInit& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_quality()) {
      set_quality(from.quality());
    }
    if (from.has_codec()) {
      set_codec(from.codec());
    }
    if (from.has_version()) {
      set_version(from.version());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void CSVCMsg_VoiceInit::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool CSVCMsg_VoiceInit::IsInitialized() const {

  return true;
}

void CSVCMsg_VoiceInit::Swap(CSVCMsg_VoiceInit* other) {
  if (other != this) {
    std::swap(quality_, other->quality_);
    std::swap(codec_, other->codec_);
    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 CSVCMsg_VoiceInit::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CSVCMsg_VoiceInit_descriptor_;
  metadata.reflection = CSVCMsg_VoiceInit_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int CSVCMsg_Print::kTextFieldNumber;
#endif  // !_MSC_VER

CSVCMsg_Print::CSVCMsg_Print()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:CSVCMsg_Print)
}

void CSVCMsg_Print::InitAsDefaultInstance() {
}

CSVCMsg_Print::CSVCMsg_Print(const CSVCMsg_Print& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:CSVCMsg_Print)
}

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

CSVCMsg_Print::~CSVCMsg_Print() {
  // @@protoc_insertion_point(destructor:CSVCMsg_Print)
  SharedDtor();
}

void CSVCMsg_Print::SharedDtor() {
  if (text_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete text_;
  }
  if (this != default_instance_) {
  }
}

void CSVCMsg_Print::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CSVCMsg_Print::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return CSVCMsg_Print_descriptor_;
}

const CSVCMsg_Print& CSVCMsg_Print::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
  return *default_instance_;
}

CSVCMsg_Print* CSVCMsg_Print::default_instance_ = NULL;

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

void CSVCMsg_Print::Clear() {
  if (has_text()) {
    if (text_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
      text_->clear();
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool CSVCMsg_Print::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:CSVCMsg_Print)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional string text = 1;
      case 1: {
        if (tag == 10) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_text()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->text().data(), this->text().length(),
            ::google::protobuf::internal::WireFormat::PARSE,
            "text");
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

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

void CSVCMsg_Print::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:CSVCMsg_Print)
  // optional string text = 1;
  if (has_text()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->text().data(), this->text().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "text");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->text(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:CSVCMsg_Print)
}

::google::protobuf::uint8* CSVCMsg_Print::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:CSVCMsg_Print)
  // optional string text = 1;
  if (has_text()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->text().data(), this->text().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "text");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        1, this->text(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:CSVCMsg_Print)
  return target;
}

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

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

  }
  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 CSVCMsg_Print::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const CSVCMsg_Print* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const CSVCMsg_Print*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void CSVCMsg_Print::MergeFrom(const CSVCMsg_Print& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_text()) {
      set_text(from.text());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void CSVCMsg_Print::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool CSVCMsg_Print::IsInitialized() const {

  return true;
}

void CSVCMsg_Print::Swap(CSVCMsg_Print* other) {
  if (other != this) {
    std::swap(text_, other->text_);
    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 CSVCMsg_Print::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CSVCMsg_Print_descriptor_;
  metadata.reflection = CSVCMsg_Print_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int CSVCMsg_Sounds_sounddata_t::kOriginXFieldNumber;
const int CSVCMsg_Sounds_sounddata_t::kOriginYFieldNumber;
const int CSVCMsg_Sounds_sounddata_t::kOriginZFieldNumber;
const int CSVCMsg_Sounds_sounddata_t::kVolumeFieldNumber;
const int CSVCMsg_Sounds_sounddata_t::kDelayValueFieldNumber;
const int CSVCMsg_Sounds_sounddata_t::kSequenceNumberFieldNumber;
const int CSVCMsg_Sounds_sounddata_t::kEntityIndexFieldNumber;
const int CSVCMsg_Sounds_sounddata_t::kChannelFieldNumber;
const int CSVCMsg_Sounds_sounddata_t::kPitchFieldNumber;
const int CSVCMsg_Sounds_sounddata_t::kFlagsFieldNumber;
const int CSVCMsg_Sounds_sounddata_t::kSoundNumFieldNumber;
const int CSVCMsg_Sounds_sounddata_t::kSoundNumHandleFieldNumber;
const int CSVCMsg_Sounds_sounddata_t::kSpeakerEntityFieldNumber;
const int CSVCMsg_Sounds_sounddata_t::kRandomSeedFieldNumber;
const int CSVCMsg_Sounds_sounddata_t::kSoundLevelFieldNumber;
const int CSVCMsg_Sounds_sounddata_t::kIsSentenceFieldNumber;
const int CSVCMsg_Sounds_sounddata_t::kIsAmbientFieldNumber;
const int CSVCMsg_Sounds_sounddata_t::kGuidFieldNumber;
const int CSVCMsg_Sounds_sounddata_t::kSoundResourceIdFieldNumber;
#endif  // !_MSC_VER

CSVCMsg_Sounds_sounddata_t::CSVCMsg_Sounds_sounddata_t()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:CSVCMsg_Sounds.sounddata_t)
}

void CSVCMsg_Sounds_sounddata_t::InitAsDefaultInstance() {
}

CSVCMsg_Sounds_sounddata_t::CSVCMsg_Sounds_sounddata_t(const CSVCMsg_Sounds_sounddata_t& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:CSVCMsg_Sounds.sounddata_t)
}

void CSVCMsg_Sounds_sounddata_t::SharedCtor() {
  _cached_size_ = 0;
  origin_x_ = 0;
  origin_y_ = 0;
  origin_z_ = 0;
  volume_ = 0u;
  delay_value_ = 0;
  sequence_number_ = 0;
  entity_index_ = 0;
  channel_ = 0;
  pitch_ = 0;
  flags_ = 0;
  sound_num_ = 0u;
  sound_num_handle_ = 0u;
  speaker_entity_ = 0;
  random_seed_ = 0;
  sound_level_ = 0;
  is_sentence_ = false;
  is_ambient_ = false;
  guid_ = 0u;
  sound_resource_id_ = GOOGLE_ULONGLONG(0);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CSVCMsg_Sounds_sounddata_t::~CSVCMsg_Sounds_sounddata_t() {
  // @@protoc_insertion_point(destructor:CSVCMsg_Sounds.sounddata_t)
  SharedDtor();
}

void CSVCMsg_Sounds_sounddata_t::SharedDtor() {
  if (this != default_instance_) {
  }
}

void CSVCMsg_Sounds_sounddata_t::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CSVCMsg_Sounds_sounddata_t::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return CSVCMsg_Sounds_sounddata_t_descriptor_;
}

const CSVCMsg_Sounds_sounddata_t& CSVCMsg_Sounds_sounddata_t::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
  return *default_instance_;
}

CSVCMsg_Sounds_sounddata_t* CSVCMsg_Sounds_sounddata_t::default_instance_ = NULL;

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

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

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

  if (_has_bits_[0 / 32] & 255) {
    ZR_(origin_x_, channel_);
  }
  if (_has_bits_[8 / 32] & 65280) {
    ZR_(pitch_, is_sentence_);
  }
  ZR_(is_ambient_, guid_);

#undef OFFSET_OF_FIELD_
#undef ZR_

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

bool CSVCMsg_Sounds_sounddata_t::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:CSVCMsg_Sounds.sounddata_t)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(16383);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional sint32 origin_x = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_SINT32>(
                 input, &origin_x_)));
          set_has_origin_x();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_origin_y;
        break;
      }

      // optional sint32 origin_y = 2;
      case 2: {
        if (tag == 16) {
         parse_origin_y:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_SINT32>(
                 input, &origin_y_)));
          set_has_origin_y();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_origin_z;
        break;
      }

      // optional sint32 origin_z = 3;
      case 3: {
        if (tag == 24) {
         parse_origin_z:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_SINT32>(
                 input, &origin_z_)));
          set_has_origin_z();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(32)) goto parse_volume;
        break;
      }

      // optional uint32 volume = 4;
      case 4: {
        if (tag == 32) {
         parse_volume:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &volume_)));
          set_has_volume();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(45)) goto parse_delay_value;
        break;
      }

      // optional float delay_value = 5;
      case 5: {
        if (tag == 45) {
         parse_delay_value:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &delay_value_)));
          set_has_delay_value();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(48)) goto parse_sequence_number;
        break;
      }

      // optional int32 sequence_number = 6;
      case 6: {
        if (tag == 48) {
         parse_sequence_number:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &sequence_number_)));
          set_has_sequence_number();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(56)) goto parse_entity_index;
        break;
      }

      // optional int32 entity_index = 7;
      case 7: {
        if (tag == 56) {
         parse_entity_index:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &entity_index_)));
          set_has_entity_index();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(64)) goto parse_channel;
        break;
      }

      // optional int32 channel = 8;
      case 8: {
        if (tag == 64) {
         parse_channel:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &channel_)));
          set_has_channel();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(72)) goto parse_pitch;
        break;
      }

      // optional int32 pitch = 9;
      case 9: {
        if (tag == 72) {
         parse_pitch:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &pitch_)));
          set_has_pitch();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(80)) goto parse_flags;
        break;
      }

      // optional int32 flags = 10;
      case 10: {
        if (tag == 80) {
         parse_flags:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &flags_)));
          set_has_flags();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(88)) goto parse_sound_num;
        break;
      }

      // optional uint32 sound_num = 11;
      case 11: {
        if (tag == 88) {
         parse_sound_num:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &sound_num_)));
          set_has_sound_num();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(101)) goto parse_sound_num_handle;
        break;
      }

      // optional fixed32 sound_num_handle = 12;
      case 12: {
        if (tag == 101) {
         parse_sound_num_handle:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
                 input, &sound_num_handle_)));
          set_has_sound_num_handle();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(104)) goto parse_speaker_entity;
        break;
      }

      // optional int32 speaker_entity = 13;
      case 13: {
        if (tag == 104) {
         parse_speaker_entity:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &speaker_entity_)));
          set_has_speaker_entity();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(112)) goto parse_random_seed;
        break;
      }

      // optional int32 random_seed = 14;
      case 14: {
        if (tag == 112) {
         parse_random_seed:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &random_seed_)));
          set_has_random_seed();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(120)) goto parse_sound_level;
        break;
      }

      // optional int32 sound_level = 15;
      case 15: {
        if (tag == 120) {
         parse_sound_level:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &sound_level_)));
          set_has_sound_level();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(128)) goto parse_is_sentence;
        break;
      }

      // optional bool is_sentence = 16;
      case 16: {
        if (tag == 128) {
         parse_is_sentence:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &is_sentence_)));
          set_has_is_sentence();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(136)) goto parse_is_ambient;
        break;
      }

      // optional bool is_ambient = 17;
      case 17: {
        if (tag == 136) {
         parse_is_ambient:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &is_ambient_)));
          set_has_is_ambient();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(144)) goto parse_guid;
        break;
      }

      // optional uint32 guid = 18;
      case 18: {
        if (tag == 144) {
         parse_guid:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &guid_)));
          set_has_guid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(153)) goto parse_sound_resource_id;
        break;
      }

      // optional fixed64 sound_resource_id = 19;
      case 19: {
        if (tag == 153) {
         parse_sound_resource_id:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                 input, &sound_resource_id_)));
          set_has_sound_resource_id();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

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

void CSVCMsg_Sounds_sounddata_t::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:CSVCMsg_Sounds.sounddata_t)
  // optional sint32 origin_x = 1;
  if (has_origin_x()) {
    ::google::protobuf::internal::WireFormatLite::WriteSInt32(1, this->origin_x(), output);
  }

  // optional sint32 origin_y = 2;
  if (has_origin_y()) {
    ::google::protobuf::internal::WireFormatLite::WriteSInt32(2, this->origin_y(), output);
  }

  // optional sint32 origin_z = 3;
  if (has_origin_z()) {
    ::google::protobuf::internal::WireFormatLite::WriteSInt32(3, this->origin_z(), output);
  }

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

  // optional float delay_value = 5;
  if (has_delay_value()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(5, this->delay_value(), output);
  }

  // optional int32 sequence_number = 6;
  if (has_sequence_number()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(6, this->sequence_number(), output);
  }

  // optional int32 entity_index = 7;
  if (has_entity_index()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(7, this->entity_index(), output);
  }

  // optional int32 channel = 8;
  if (has_channel()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(8, this->channel(), output);
  }

  // optional int32 pitch = 9;
  if (has_pitch()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(9, this->pitch(), output);
  }

  // optional int32 flags = 10;
  if (has_flags()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(10, this->flags(), output);
  }

  // optional uint32 sound_num = 11;
  if (has_sound_num()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(11, this->sound_num(), output);
  }

  // optional fixed32 sound_num_handle = 12;
  if (has_sound_num_handle()) {
    ::google::protobuf::internal::WireFormatLite::WriteFixed32(12, this->sound_num_handle(), output);
  }

  // optional int32 speaker_entity = 13;
  if (has_speaker_entity()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(13, this->speaker_entity(), output);
  }

  // optional int32 random_seed = 14;
  if (has_random_seed()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(14, this->random_seed(), output);
  }

  // optional int32 sound_level = 15;
  if (has_sound_level()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(15, this->sound_level(), output);
  }

  // optional bool is_sentence = 16;
  if (has_is_sentence()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(16, this->is_sentence(), output);
  }

  // optional bool is_ambient = 17;
  if (has_is_ambient()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(17, this->is_ambient(), output);
  }

  // optional uint32 guid = 18;
  if (has_guid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(18, this->guid(), output);
  }

  // optional fixed64 sound_resource_id = 19;
  if (has_sound_resource_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteFixed64(19, this->sound_resource_id(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:CSVCMsg_Sounds.sounddata_t)
}

::google::protobuf::uint8* CSVCMsg_Sounds_sounddata_t::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:CSVCMsg_Sounds.sounddata_t)
  // optional sint32 origin_x = 1;
  if (has_origin_x()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteSInt32ToArray(1, this->origin_x(), target);
  }

  // optional sint32 origin_y = 2;
  if (has_origin_y()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteSInt32ToArray(2, this->origin_y(), target);
  }

  // optional sint32 origin_z = 3;
  if (has_origin_z()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteSInt32ToArray(3, this->origin_z(), target);
  }

  // optional uint32 volume = 4;
  if (has_volume()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(4, this->volume(), target);
  }

  // optional float delay_value = 5;
  if (has_delay_value()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(5, this->delay_value(), target);
  }

  // optional int32 sequence_number = 6;
  if (has_sequence_number()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(6, this->sequence_number(), target);
  }

  // optional int32 entity_index = 7;
  if (has_entity_index()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(7, this->entity_index(), target);
  }

  // optional int32 channel = 8;
  if (has_channel()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(8, this->channel(), target);
  }

  // optional int32 pitch = 9;
  if (has_pitch()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(9, this->pitch(), target);
  }

  // optional int32 flags = 10;
  if (has_flags()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(10, this->flags(), target);
  }

  // optional uint32 sound_num = 11;
  if (has_sound_num()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(11, this->sound_num(), target);
  }

  // optional fixed32 sound_num_handle = 12;
  if (has_sound_num_handle()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(12, this->sound_num_handle(), target);
  }

  // optional int32 speaker_entity = 13;
  if (has_speaker_entity()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(13, this->speaker_entity(), target);
  }

  // optional int32 random_seed = 14;
  if (has_random_seed()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(14, this->random_seed(), target);
  }

  // optional int32 sound_level = 15;
  if (has_sound_level()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(15, this->sound_level(), target);
  }

  // optional bool is_sentence = 16;
  if (has_is_sentence()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(16, this->is_sentence(), target);
  }

  // optional bool is_ambient = 17;
  if (has_is_ambient()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(17, this->is_ambient(), target);
  }

  // optional uint32 guid = 18;
  if (has_guid()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(18, this->guid(), target);
  }

  // optional fixed64 sound_resource_id = 19;
  if (has_sound_resource_id()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(19, this->sound_resource_id(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:CSVCMsg_Sounds.sounddata_t)
  return target;
}

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional sint32 origin_x = 1;
    if (has_origin_x()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::SInt32Size(
          this->origin_x());
    }

    // optional sint32 origin_y = 2;
    if (has_origin_y()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::SInt32Size(
          this->origin_y());
    }

    // optional sint32 origin_z = 3;
    if (has_origin_z()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::SInt32Size(
          this->origin_z());
    }

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

    // optional float delay_value = 5;
    if (has_delay_value()) {
      total_size += 1 + 4;
    }

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

    // optional int32 entity_index = 7;
    if (has_entity_index()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->entity_index());
    }

    // optional int32 channel = 8;
    if (has_channel()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->channel());
    }

  }
  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
    // optional int32 pitch = 9;
    if (has_pitch()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->pitch());
    }

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

    // optional uint32 sound_num = 11;
    if (has_sound_num()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->sound_num());
    }

    // optional fixed32 sound_num_handle = 12;
    if (has_sound_num_handle()) {
      total_size += 1 + 4;
    }

    // optional int32 speaker_entity = 13;
    if (has_speaker_entity()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->speaker_entity());
    }

    // optional int32 random_seed = 14;
    if (has_random_seed()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->random_seed());
    }

    // optional int32 sound_level = 15;
    if (has_sound_level()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->sound_level());
    }

    // optional bool is_sentence = 16;
    if (has_is_sentence()) {
      total_size += 2 + 1;
    }

  }
  if (_has_bits_[16 / 32] & (0xffu << (16 % 32))) {
    // optional bool is_ambient = 17;
    if (has_is_ambient()) {
      total_size += 2 + 1;
    }

    // optional uint32 guid = 18;
    if (has_guid()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->guid());
    }

    // optional fixed64 sound_resource_id = 19;
    if (has_sound_resource_id()) {
      total_size += 2 + 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 CSVCMsg_Sounds_sounddata_t::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const CSVCMsg_Sounds_sounddata_t* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const CSVCMsg_Sounds_sounddata_t*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void CSVCMsg_Sounds_sounddata_t::MergeFrom(const CSVCMsg_Sounds_sounddata_t& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_origin_x()) {
      set_origin_x(from.origin_x());
    }
    if (from.has_origin_y()) {
      set_origin_y(from.origin_y());
    }
    if (from.has_origin_z()) {
      set_origin_z(from.origin_z());
    }
    if (from.has_volume()) {
      set_volume(from.volume());
    }
    if (from.has_delay_value()) {
      set_delay_value(from.delay_value());
    }
    if (from.has_sequence_number()) {
      set_sequence_number(from.sequence_number());
    }
    if (from.has_entity_index()) {
      set_entity_index(from.entity_index());
    }
    if (from.has_channel()) {
      set_channel(from.channel());
    }
  }
  if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
    if (from.has_pitch()) {
      set_pitch(from.pitch());
    }
    if (from.has_flags()) {
      set_flags(from.flags());
    }
    if (from.has_sound_num()) {
      set_sound_num(from.sound_num());
    }
    if (from.has_sound_num_handle()) {
      set_sound_num_handle(from.sound_num_handle());
    }
    if (from.has_speaker_entity()) {
      set_speaker_entity(from.speaker_entity());
    }
    if (from.has_random_seed()) {
      set_random_seed(from.random_seed());
    }
    if (from.has_sound_level()) {
      set_sound_level(from.sound_level());
    }
    if (from.has_is_sentence()) {
      set_is_sentence(from.is_sentence());
    }
  }
  if (from._has_bits_[16 / 32] & (0xffu << (16 % 32))) {
    if (from.has_is_ambient()) {
      set_is_ambient(from.is_ambient());
    }
    if (from.has_guid()) {
      set_guid(from.guid());
    }
    if (from.has_sound_resource_id()) {
      set_sound_resource_id(from.sound_resource_id());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void CSVCMsg_Sounds_sounddata_t::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool CSVCMsg_Sounds_sounddata_t::IsInitialized() const {

  return true;
}

void CSVCMsg_Sounds_sounddata_t::Swap(CSVCMsg_Sounds_sounddata_t* other) {
  if (other != this) {
    std::swap(origin_x_, other->origin_x_);
    std::swap(origin_y_, other->origin_y_);
    std::swap(origin_z_, other->origin_z_);
    std::swap(volume_, other->volume_);
    std::swap(delay_value_, other->delay_value_);
    std::swap(sequence_number_, other->sequence_number_);
    std::swap(entity_index_, other->entity_index_);
    std::swap(channel_, other->channel_);
    std::swap(pitch_, other->pitch_);
    std::swap(flags_, other->flags_);
    std::swap(sound_num_, other->sound_num_);
    std::swap(sound_num_handle_, other->sound_num_handle_);
    std::swap(speaker_entity_, other->speaker_entity_);
    std::swap(random_seed_, other->random_seed_);
    std::swap(sound_level_, other->sound_level_);
    std::swap(is_sentence_, other->is_sentence_);
    std::swap(is_ambient_, other->is_ambient_);
    std::swap(guid_, other->guid_);
    std::swap(sound_resource_id_, other->sound_resource_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 CSVCMsg_Sounds_sounddata_t::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CSVCMsg_Sounds_sounddata_t_descriptor_;
  metadata.reflection = CSVCMsg_Sounds_sounddata_t_reflection_;
  return metadata;
}


// -------------------------------------------------------------------

#ifndef _MSC_VER
const int CSVCMsg_Sounds::kReliableSoundFieldNumber;
const int CSVCMsg_Sounds::kSoundsFieldNumber;
#endif  // !_MSC_VER

CSVCMsg_Sounds::CSVCMsg_Sounds()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:CSVCMsg_Sounds)
}

void CSVCMsg_Sounds::InitAsDefaultInstance() {
}

CSVCMsg_Sounds::CSVCMsg_Sounds(const CSVCMsg_Sounds& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:CSVCMsg_Sounds)
}

void CSVCMsg_Sounds::SharedCtor() {
  _cached_size_ = 0;
  reliable_sound_ = false;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CSVCMsg_Sounds::~CSVCMsg_Sounds() {
  // @@protoc_insertion_point(destructor:CSVCMsg_Sounds)
  SharedDtor();
}

void CSVCMsg_Sounds::SharedDtor() {
  if (this != default_instance_) {
  }
}

void CSVCMsg_Sounds::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CSVCMsg_Sounds::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return CSVCMsg_Sounds_descriptor_;
}

const CSVCMsg_Sounds& CSVCMsg_Sounds::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
  return *default_instance_;
}

CSVCMsg_Sounds* CSVCMsg_Sounds::default_instance_ = NULL;

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

void CSVCMsg_Sounds::Clear() {
  reliable_sound_ = false;
  sounds_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool CSVCMsg_Sounds::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:CSVCMsg_Sounds)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional bool reliable_sound = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &reliable_sound_)));
          set_has_reliable_sound();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_sounds;
        break;
      }

      // repeated .CSVCMsg_Sounds.sounddata_t sounds = 2;
      case 2: {
        if (tag == 18) {
         parse_sounds:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_sounds()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_sounds;
        if (input->ExpectAtEnd()) goto success;
        break;
      }

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

void CSVCMsg_Sounds::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:CSVCMsg_Sounds)
  // optional bool reliable_sound = 1;
  if (has_reliable_sound()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->reliable_sound(), output);
  }

  // repeated .CSVCMsg_Sounds.sounddata_t sounds = 2;
  for (int i = 0; i < this->sounds_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      2, this->sounds(i), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:CSVCMsg_Sounds)
}

::google::protobuf::uint8* CSVCMsg_Sounds::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:CSVCMsg_Sounds)
  // optional bool reliable_sound = 1;
  if (has_reliable_sound()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(1, this->reliable_sound(), target);
  }

  // repeated .CSVCMsg_Sounds.sounddata_t sounds = 2;
  for (int i = 0; i < this->sounds_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        2, this->sounds(i), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:CSVCMsg_Sounds)
  return target;
}

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional bool reliable_sound = 1;
    if (has_reliable_sound()) {
      total_size += 1 + 1;
    }

  }
  // repeated .CSVCMsg_Sounds.sounddata_t sounds = 2;
  total_size += 1 * this->sounds_size();
  for (int i = 0; i < this->sounds_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->sounds(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 CSVCMsg_Sounds::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const CSVCMsg_Sounds* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const CSVCMsg_Sounds*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void CSVCMsg_Sounds::MergeFrom(const CSVCMsg_Sounds& from) {
  GOOGLE_CHECK_NE(&from, this);
  sounds_.MergeFrom(from.sounds_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_reliable_sound()) {
      set_reliable_sound(from.reliable_sound());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void CSVCMsg_Sounds::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool CSVCMsg_Sounds::IsInitialized() const {

  return true;
}

void CSVCMsg_Sounds::Swap(CSVCMsg_Sounds* other) {
  if (other != this) {
    std::swap(reliable_sound_, other->reliable_sound_);
    sounds_.Swap(&other->sounds_);
    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 CSVCMsg_Sounds::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CSVCMsg_Sounds_descriptor_;
  metadata.reflection = CSVCMsg_Sounds_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int CSVCMsg_Prefetch::kSoundIndexFieldNumber;
const int CSVCMsg_Prefetch::kResourceTypeFieldNumber;
#endif  // !_MSC_VER

CSVCMsg_Prefetch::CSVCMsg_Prefetch()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:CSVCMsg_Prefetch)
}

void CSVCMsg_Prefetch::InitAsDefaultInstance() {
}

CSVCMsg_Prefetch::CSVCMsg_Prefetch(const CSVCMsg_Prefetch& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:CSVCMsg_Prefetch)
}

void CSVCMsg_Prefetch::SharedCtor() {
  _cached_size_ = 0;
  sound_index_ = 0;
  resource_type_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CSVCMsg_Prefetch::~CSVCMsg_Prefetch() {
  // @@protoc_insertion_point(destructor:CSVCMsg_Prefetch)
  SharedDtor();
}

void CSVCMsg_Prefetch::SharedDtor() {
  if (this != default_instance_) {
  }
}

void CSVCMsg_Prefetch::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CSVCMsg_Prefetch::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return CSVCMsg_Prefetch_descriptor_;
}

const CSVCMsg_Prefetch& CSVCMsg_Prefetch::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
  return *default_instance_;
}

CSVCMsg_Prefetch* CSVCMsg_Prefetch::default_instance_ = NULL;

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

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

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

  ZR_(sound_index_, resource_type_);

#undef OFFSET_OF_FIELD_
#undef ZR_

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

bool CSVCMsg_Prefetch::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:CSVCMsg_Prefetch)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 sound_index = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &sound_index_)));
          set_has_sound_index();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_resource_type;
        break;
      }

      // optional .PrefetchType resource_type = 2 [default = PFT_SOUND];
      case 2: {
        if (tag == 16) {
         parse_resource_type:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::PrefetchType_IsValid(value)) {
            set_resource_type(static_cast< ::PrefetchType >(value));
          } else {
            mutable_unknown_fields()->AddVarint(2, value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

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

void CSVCMsg_Prefetch::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:CSVCMsg_Prefetch)
  // optional int32 sound_index = 1;
  if (has_sound_index()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->sound_index(), output);
  }

  // optional .PrefetchType resource_type = 2 [default = PFT_SOUND];
  if (has_resource_type()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      2, this->resource_type(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:CSVCMsg_Prefetch)
}

::google::protobuf::uint8* CSVCMsg_Prefetch::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:CSVCMsg_Prefetch)
  // optional int32 sound_index = 1;
  if (has_sound_index()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->sound_index(), target);
  }

  // optional .PrefetchType resource_type = 2 [default = PFT_SOUND];
  if (has_resource_type()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      2, this->resource_type(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:CSVCMsg_Prefetch)
  return target;
}

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional int32 sound_index = 1;
    if (has_sound_index()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->sound_index());
    }

    // optional .PrefetchType resource_type = 2 [default = PFT_SOUND];
    if (has_resource_type()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->resource_type());
    }

  }
  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 CSVCMsg_Prefetch::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const CSVCMsg_Prefetch* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const CSVCMsg_Prefetch*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void CSVCMsg_Prefetch::MergeFrom(const CSVCMsg_Prefetch& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_sound_index()) {
      set_sound_index(from.sound_index());
    }
    if (from.has_resource_type()) {
      set_resource_type(from.resource_type());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void CSVCMsg_Prefetch::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool CSVCMsg_Prefetch::IsInitialized() const {

  return true;
}

void CSVCMsg_Prefetch::Swap(CSVCMsg_Prefetch* other) {
  if (other != this) {
    std::swap(sound_index_, other->sound_index_);
    std::swap(resource_type_, other->resource_type_);
    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 CSVCMsg_Prefetch::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CSVCMsg_Prefetch_descriptor_;
  metadata.reflection = CSVCMsg_Prefetch_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int CSVCMsg_SetView::kEntityIndexFieldNumber;
const int CSVCMsg_SetView::kSlotFieldNumber;
#endif  // !_MSC_VER

CSVCMsg_SetView::CSVCMsg_SetView()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:CSVCMsg_SetView)
}

void CSVCMsg_SetView::InitAsDefaultInstance() {
}

CSVCMsg_SetView::CSVCMsg_SetView(const CSVCMsg_SetView& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:CSVCMsg_SetView)
}

void CSVCMsg_SetView::SharedCtor() {
  _cached_size_ = 0;
  entity_index_ = 0;
  slot_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CSVCMsg_SetView::~CSVCMsg_SetView() {
  // @@protoc_insertion_point(destructor:CSVCMsg_SetView)
  SharedDtor();
}

void CSVCMsg_SetView::SharedDtor() {
  if (this != default_instance_) {
  }
}

void CSVCMsg_SetView::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CSVCMsg_SetView::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return CSVCMsg_SetView_descriptor_;
}

const CSVCMsg_SetView& CSVCMsg_SetView::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
  return *default_instance_;
}

CSVCMsg_SetView* CSVCMsg_SetView::default_instance_ = NULL;

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

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

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

  ZR_(entity_index_, slot_);

#undef OFFSET_OF_FIELD_
#undef ZR_

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

bool CSVCMsg_SetView::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:CSVCMsg_SetView)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 entity_index = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &entity_index_)));
          set_has_entity_index();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_slot;
        break;
      }

      // optional int32 slot = 2;
      case 2: {
        if (tag == 16) {
         parse_slot:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &slot_)));
          set_has_slot();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

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

void CSVCMsg_SetView::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:CSVCMsg_SetView)
  // optional int32 entity_index = 1;
  if (has_entity_index()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->entity_index(), output);
  }

  // optional int32 slot = 2;
  if (has_slot()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->slot(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:CSVCMsg_SetView)
}

::google::protobuf::uint8* CSVCMsg_SetView::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:CSVCMsg_SetView)
  // optional int32 entity_index = 1;
  if (has_entity_index()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->entity_index(), target);
  }

  // optional int32 slot = 2;
  if (has_slot()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->slot(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:CSVCMsg_SetView)
  return target;
}

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional int32 entity_index = 1;
    if (has_entity_index()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->entity_index());
    }

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

  }
  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 CSVCMsg_SetView::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const CSVCMsg_SetView* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const CSVCMsg_SetView*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void CSVCMsg_SetView::MergeFrom(const CSVCMsg_SetView& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_entity_index()) {
      set_entity_index(from.entity_index());
    }
    if (from.has_slot()) {
      set_slot(from.slot());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void CSVCMsg_SetView::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool CSVCMsg_SetView::IsInitialized() const {

  return true;
}

void CSVCMsg_SetView::Swap(CSVCMsg_SetView* other) {
  if (other != this) {
    std::swap(entity_index_, other->entity_index_);
    std::swap(slot_, other->slot_);
    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 CSVCMsg_SetView::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CSVCMsg_SetView_descriptor_;
  metadata.reflection = CSVCMsg_SetView_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int CSVCMsg_FixAngle::kRelativeFieldNumber;
const int CSVCMsg_FixAngle::kAngleFieldNumber;
#endif  // !_MSC_VER

CSVCMsg_FixAngle::CSVCMsg_FixAngle()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:CSVCMsg_FixAngle)
}

void CSVCMsg_FixAngle::InitAsDefaultInstance() {
  angle_ = const_cast< ::CMsgQAngle*>(&::CMsgQAngle::default_instance());
}

CSVCMsg_FixAngle::CSVCMsg_FixAngle(const CSVCMsg_FixAngle& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:CSVCMsg_FixAngle)
}

void CSVCMsg_FixAngle::SharedCtor() {
  _cached_size_ = 0;
  relative_ = false;
  angle_ = NULL;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CSVCMsg_FixAngle::~CSVCMsg_FixAngle() {
  // @@protoc_insertion_point(destructor:CSVCMsg_FixAngle)
  SharedDtor();
}

void CSVCMsg_FixAngle::SharedDtor() {
  if (this != default_instance_) {
    delete angle_;
  }
}

void CSVCMsg_FixAngle::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CSVCMsg_FixAngle::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return CSVCMsg_FixAngle_descriptor_;
}

const CSVCMsg_FixAngle& CSVCMsg_FixAngle::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
  return *default_instance_;
}

CSVCMsg_FixAngle* CSVCMsg_FixAngle::default_instance_ = NULL;

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

void CSVCMsg_FixAngle::Clear() {
  if (_has_bits_[0 / 32] & 3) {
    relative_ = false;
    if (has_angle()) {
      if (angle_ != NULL) angle_->::CMsgQAngle::Clear();
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool CSVCMsg_FixAngle::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:CSVCMsg_FixAngle)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional bool relative = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &relative_)));
          set_has_relative();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_angle;
        break;
      }

      // optional .CMsgQAngle angle = 2;
      case 2: {
        if (tag == 18) {
         parse_angle:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_angle()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

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

void CSVCMsg_FixAngle::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:CSVCMsg_FixAngle)
  // optional bool relative = 1;
  if (has_relative()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->relative(), output);
  }

  // optional .CMsgQAngle angle = 2;
  if (has_angle()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      2, this->angle(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:CSVCMsg_FixAngle)
}

::google::protobuf::uint8* CSVCMsg_FixAngle::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:CSVCMsg_FixAngle)
  // optional bool relative = 1;
  if (has_relative()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(1, this->relative(), target);
  }

  // optional .CMsgQAngle angle = 2;
  if (has_angle()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        2, this->angle(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:CSVCMsg_FixAngle)
  return target;
}

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional bool relative = 1;
    if (has_relative()) {
      total_size += 1 + 1;
    }

    // optional .CMsgQAngle angle = 2;
    if (has_angle()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->angle());
    }

  }
  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 CSVCMsg_FixAngle::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const CSVCMsg_FixAngle* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const CSVCMsg_FixAngle*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void CSVCMsg_FixAngle::MergeFrom(const CSVCMsg_FixAngle& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_relative()) {
      set_relative(from.relative());
    }
    if (from.has_angle()) {
      mutable_angle()->::CMsgQAngle::MergeFrom(from.angle());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void CSVCMsg_FixAngle::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool CSVCMsg_FixAngle::IsInitialized() const {

  return true;
}

void CSVCMsg_FixAngle::Swap(CSVCMsg_FixAngle* other) {
  if (other != this) {
    std::swap(relative_, other->relative_);
    std::swap(angle_, other->angle_);
    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 CSVCMsg_FixAngle::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CSVCMsg_FixAngle_descriptor_;
  metadata.reflection = CSVCMsg_FixAngle_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int CSVCMsg_CrosshairAngle::kAngleFieldNumber;
#endif  // !_MSC_VER

CSVCMsg_CrosshairAngle::CSVCMsg_CrosshairAngle()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:CSVCMsg_CrosshairAngle)
}

void CSVCMsg_CrosshairAngle::InitAsDefaultInstance() {
  angle_ = const_cast< ::CMsgQAngle*>(&::CMsgQAngle::default_instance());
}

CSVCMsg_CrosshairAngle::CSVCMsg_CrosshairAngle(const CSVCMsg_CrosshairAngle& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:CSVCMsg_CrosshairAngle)
}

void CSVCMsg_CrosshairAngle::SharedCtor() {
  _cached_size_ = 0;
  angle_ = NULL;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CSVCMsg_CrosshairAngle::~CSVCMsg_CrosshairAngle() {
  // @@protoc_insertion_point(destructor:CSVCMsg_CrosshairAngle)
  SharedDtor();
}

void CSVCMsg_CrosshairAngle::SharedDtor() {
  if (this != default_instance_) {
    delete angle_;
  }
}

void CSVCMsg_CrosshairAngle::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CSVCMsg_CrosshairAngle::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return CSVCMsg_CrosshairAngle_descriptor_;
}

const CSVCMsg_CrosshairAngle& CSVCMsg_CrosshairAngle::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
  return *default_instance_;
}

CSVCMsg_CrosshairAngle* CSVCMsg_CrosshairAngle::default_instance_ = NULL;

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

void CSVCMsg_CrosshairAngle::Clear() {
  if (has_angle()) {
    if (angle_ != NULL) angle_->::CMsgQAngle::Clear();
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool CSVCMsg_CrosshairAngle::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:CSVCMsg_CrosshairAngle)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .CMsgQAngle angle = 1;
      case 1: {
        if (tag == 10) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_angle()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

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

void CSVCMsg_CrosshairAngle::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:CSVCMsg_CrosshairAngle)
  // optional .CMsgQAngle angle = 1;
  if (has_angle()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->angle(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:CSVCMsg_CrosshairAngle)
}

::google::protobuf::uint8* CSVCMsg_CrosshairAngle::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:CSVCMsg_CrosshairAngle)
  // optional .CMsgQAngle angle = 1;
  if (has_angle()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->angle(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:CSVCMsg_CrosshairAngle)
  return target;
}

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional .CMsgQAngle angle = 1;
    if (has_angle()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->angle());
    }

  }
  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 CSVCMsg_CrosshairAngle::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const CSVCMsg_CrosshairAngle* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const CSVCMsg_CrosshairAngle*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void CSVCMsg_CrosshairAngle::MergeFrom(const CSVCMsg_CrosshairAngle& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_angle()) {
      mutable_angle()->::CMsgQAngle::MergeFrom(from.angle());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void CSVCMsg_CrosshairAngle::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool CSVCMsg_CrosshairAngle::IsInitialized() const {

  return true;
}

void CSVCMsg_CrosshairAngle::Swap(CSVCMsg_CrosshairAngle* other) {
  if (other != this) {
    std::swap(angle_, other->angle_);
    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 CSVCMsg_CrosshairAngle::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CSVCMsg_CrosshairAngle_descriptor_;
  metadata.reflection = CSVCMsg_CrosshairAngle_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int CSVCMsg_BSPDecal::kPosFieldNumber;
const int CSVCMsg_BSPDecal::kDecalTextureIndexFieldNumber;
const int CSVCMsg_BSPDecal::kEntityIndexFieldNumber;
const int CSVCMsg_BSPDecal::kModelIndexFieldNumber;
const int CSVCMsg_BSPDecal::kLowPriorityFieldNumber;
#endif  // !_MSC_VER

CSVCMsg_BSPDecal::CSVCMsg_BSPDecal()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:CSVCMsg_BSPDecal)
}

void CSVCMsg_BSPDecal::InitAsDefaultInstance() {
  pos_ = const_cast< ::CMsgVector*>(&::CMsgVector::default_instance());
}

CSVCMsg_BSPDecal::CSVCMsg_BSPDecal(const CSVCMsg_BSPDecal& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:CSVCMsg_BSPDecal)
}

void CSVCMsg_BSPDecal::SharedCtor() {
  _cached_size_ = 0;
  pos_ = NULL;
  decal_texture_index_ = 0;
  entity_index_ = 0;
  model_index_ = 0;
  low_priority_ = false;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CSVCMsg_BSPDecal::~CSVCMsg_BSPDecal() {
  // @@protoc_insertion_point(destructor:CSVCMsg_BSPDecal)
  SharedDtor();
}

void CSVCMsg_BSPDecal::SharedDtor() {
  if (this != default_instance_) {
    delete pos_;
  }
}

void CSVCMsg_BSPDecal::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CSVCMsg_BSPDecal::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return CSVCMsg_BSPDecal_descriptor_;
}

const CSVCMsg_BSPDecal& CSVCMsg_BSPDecal::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
  return *default_instance_;
}

CSVCMsg_BSPDecal* CSVCMsg_BSPDecal::default_instance_ = NULL;

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

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

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

  if (_has_bits_[0 / 32] & 31) {
    ZR_(decal_texture_index_, low_priority_);
    if (has_pos()) {
      if (pos_ != NULL) pos_->::CMsgVector::Clear();
    }
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

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

bool CSVCMsg_BSPDecal::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:CSVCMsg_BSPDecal)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .CMsgVector pos = 1;
      case 1: {
        if (tag == 10) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_pos()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_decal_texture_index;
        break;
      }

      // optional int32 decal_texture_index = 2;
      case 2: {
        if (tag == 16) {
         parse_decal_texture_index:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &decal_texture_index_)));
          set_has_decal_texture_index();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_entity_index;
        break;
      }

      // optional int32 entity_index = 3;
      case 3: {
        if (tag == 24) {
         parse_entity_index:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &entity_index_)));
          set_has_entity_index();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(32)) goto parse_model_index;
        break;
      }

      // optional int32 model_index = 4;
      case 4: {
        if (tag == 32) {
         parse_model_index:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &model_index_)));
          set_has_model_index();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(40)) goto parse_low_priority;
        break;
      }

      // optional bool low_priority = 5;
      case 5: {
        if (tag == 40) {
         parse_low_priority:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &low_priority_)));
          set_has_low_priority();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

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

void CSVCMsg_BSPDecal::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:CSVCMsg_BSPDecal)
  // optional .CMsgVector pos = 1;
  if (has_pos()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->pos(), output);
  }

  // optional int32 decal_texture_index = 2;
  if (has_decal_texture_index()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->decal_texture_index(), output);
  }

  // optional int32 entity_index = 3;
  if (has_entity_index()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->entity_index(), output);
  }

  // optional int32 model_index = 4;
  if (has_model_index()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->model_index(), output);
  }

  // optional bool low_priority = 5;
  if (has_low_priority()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(5, this->low_priority(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:CSVCMsg_BSPDecal)
}

::google::protobuf::uint8* CSVCMsg_BSPDecal::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:CSVCMsg_BSPDecal)
  // optional .CMsgVector pos = 1;
  if (has_pos()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->pos(), target);
  }

  // optional int32 decal_texture_index = 2;
  if (has_decal_texture_index()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->decal_texture_index(), target);
  }

  // optional int32 entity_index = 3;
  if (has_entity_index()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->entity_index(), target);
  }

  // optional int32 model_index = 4;
  if (has_model_index()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(4, this->model_index(), target);
  }

  // optional bool low_priority = 5;
  if (has_low_priority()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(5, this->low_priority(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:CSVCMsg_BSPDecal)
  return target;
}

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional .CMsgVector pos = 1;
    if (has_pos()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->pos());
    }

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

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

    // optional int32 model_index = 4;
    if (has_model_index()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->model_index());
    }

    // optional bool low_priority = 5;
    if (has_low_priority()) {
      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 CSVCMsg_BSPDecal::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const CSVCMsg_BSPDecal* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const CSVCMsg_BSPDecal*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void CSVCMsg_BSPDecal::MergeFrom(const CSVCMsg_BSPDecal& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_pos()) {
      mutable_pos()->::CMsgVector::MergeFrom(from.pos());
    }
    if (from.has_decal_texture_index()) {
      set_decal_texture_index(from.decal_texture_index());
    }
    if (from.has_entity_index()) {
      set_entity_index(from.entity_index());
    }
    if (from.has_model_index()) {
      set_model_index(from.model_index());
    }
    if (from.has_low_priority()) {
      set_low_priority(from.low_priority());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void CSVCMsg_BSPDecal::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool CSVCMsg_BSPDecal::IsInitialized() const {

  return true;
}

void CSVCMsg_BSPDecal::Swap(CSVCMsg_BSPDecal* other) {
  if (other != this) {
    std::swap(pos_, other->pos_);
    std::swap(decal_texture_index_, other->decal_texture_index_);
    std::swap(entity_index_, other->entity_index_);
    std::swap(model_index_, other->model_index_);
    std::swap(low_priority_, other->low_priority_);
    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 CSVCMsg_BSPDecal::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CSVCMsg_BSPDecal_descriptor_;
  metadata.reflection = CSVCMsg_BSPDecal_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int CSVCMsg_SplitScreen::kTypeFieldNumber;
const int CSVCMsg_SplitScreen::kSlotFieldNumber;
const int CSVCMsg_SplitScreen::kPlayerIndexFieldNumber;
#endif  // !_MSC_VER

CSVCMsg_SplitScreen::CSVCMsg_SplitScreen()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:CSVCMsg_SplitScreen)
}

void CSVCMsg_SplitScreen::InitAsDefaultInstance() {
}

CSVCMsg_SplitScreen::CSVCMsg_SplitScreen(const CSVCMsg_SplitScreen& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:CSVCMsg_SplitScreen)
}

void CSVCMsg_SplitScreen::SharedCtor() {
  _cached_size_ = 0;
  type_ = 0;
  slot_ = 0;
  player_index_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CSVCMsg_SplitScreen::~CSVCMsg_SplitScreen() {
  // @@protoc_insertion_point(destructor:CSVCMsg_SplitScreen)
  SharedDtor();
}

void CSVCMsg_SplitScreen::SharedDtor() {
  if (this != default_instance_) {
  }
}

void CSVCMsg_SplitScreen::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CSVCMsg_SplitScreen::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return CSVCMsg_SplitScreen_descriptor_;
}

const CSVCMsg_SplitScreen& CSVCMsg_SplitScreen::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
  return *default_instance_;
}

CSVCMsg_SplitScreen* CSVCMsg_SplitScreen::default_instance_ = NULL;

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

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

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

  ZR_(type_, player_index_);

#undef OFFSET_OF_FIELD_
#undef ZR_

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

bool CSVCMsg_SplitScreen::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:CSVCMsg_SplitScreen)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .ESplitScreenMessageType type = 1 [default = MSG_SPLITSCREEN_ADDUSER];
      case 1: {
        if (tag == 8) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::ESplitScreenMessageType_IsValid(value)) {
            set_type(static_cast< ::ESplitScreenMessageType >(value));
          } else {
            mutable_unknown_fields()->AddVarint(1, value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_slot;
        break;
      }

      // optional int32 slot = 2;
      case 2: {
        if (tag == 16) {
         parse_slot:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &slot_)));
          set_has_slot();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_player_index;
        break;
      }

      // optional int32 player_index = 3;
      case 3: {
        if (tag == 24) {
         parse_player_index:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &player_index_)));
          set_has_player_index();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

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

void CSVCMsg_SplitScreen::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:CSVCMsg_SplitScreen)
  // optional .ESplitScreenMessageType type = 1 [default = MSG_SPLITSCREEN_ADDUSER];
  if (has_type()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->type(), output);
  }

  // optional int32 slot = 2;
  if (has_slot()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->slot(), output);
  }

  // optional int32 player_index = 3;
  if (has_player_index()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->player_index(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:CSVCMsg_SplitScreen)
}

::google::protobuf::uint8* CSVCMsg_SplitScreen::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:CSVCMsg_SplitScreen)
  // optional .ESplitScreenMessageType type = 1 [default = MSG_SPLITSCREEN_ADDUSER];
  if (has_type()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->type(), target);
  }

  // optional int32 slot = 2;
  if (has_slot()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->slot(), target);
  }

  // optional int32 player_index = 3;
  if (has_player_index()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->player_index(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:CSVCMsg_SplitScreen)
  return target;
}

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional .ESplitScreenMessageType type = 1 [default = MSG_SPLITSCREEN_ADDUSER];
    if (has_type()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->type());
    }

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

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

  }
  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 CSVCMsg_SplitScreen::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const CSVCMsg_SplitScreen* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const CSVCMsg_SplitScreen*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void CSVCMsg_SplitScreen::MergeFrom(const CSVCMsg_SplitScreen& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_type()) {
      set_type(from.type());
    }
    if (from.has_slot()) {
      set_slot(from.slot());
    }
    if (from.has_player_index()) {
      set_player_index(from.player_index());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void CSVCMsg_SplitScreen::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool CSVCMsg_SplitScreen::IsInitialized() const {

  return true;
}

void CSVCMsg_SplitScreen::Swap(CSVCMsg_SplitScreen* other) {
  if (other != this) {
    std::swap(type_, other->type_);
    std::swap(slot_, other->slot_);
    std::swap(player_index_, other->player_index_);
    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 CSVCMsg_SplitScreen::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CSVCMsg_SplitScreen_descriptor_;
  metadata.reflection = CSVCMsg_SplitScreen_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int CSVCMsg_GetCvarValue::kCookieFieldNumber;
const int CSVCMsg_GetCvarValue::kCvarNameFieldNumber;
#endif  // !_MSC_VER

CSVCMsg_GetCvarValue::CSVCMsg_GetCvarValue()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:CSVCMsg_GetCvarValue)
}

void CSVCMsg_GetCvarValue::InitAsDefaultInstance() {
}

CSVCMsg_GetCvarValue::CSVCMsg_GetCvarValue(const CSVCMsg_GetCvarValue& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:CSVCMsg_GetCvarValue)
}

void CSVCMsg_GetCvarValue::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  cookie_ = 0;
  cvar_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CSVCMsg_GetCvarValue::~CSVCMsg_GetCvarValue() {
  // @@protoc_insertion_point(destructor:CSVCMsg_GetCvarValue)
  SharedDtor();
}

void CSVCMsg_GetCvarValue::SharedDtor() {
  if (cvar_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete cvar_name_;
  }
  if (this != default_instance_) {
  }
}

void CSVCMsg_GetCvarValue::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CSVCMsg_GetCvarValue::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return CSVCMsg_GetCvarValue_descriptor_;
}

const CSVCMsg_GetCvarValue& CSVCMsg_GetCvarValue::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
  return *default_instance_;
}

CSVCMsg_GetCvarValue* CSVCMsg_GetCvarValue::default_instance_ = NULL;

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

void CSVCMsg_GetCvarValue::Clear() {
  if (_has_bits_[0 / 32] & 3) {
    cookie_ = 0;
    if (has_cvar_name()) {
      if (cvar_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        cvar_name_->clear();
      }
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool CSVCMsg_GetCvarValue::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:CSVCMsg_GetCvarValue)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 cookie = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &cookie_)));
          set_has_cookie();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_cvar_name;
        break;
      }

      // optional string cvar_name = 2;
      case 2: {
        if (tag == 18) {
         parse_cvar_name:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_cvar_name()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->cvar_name().data(), this->cvar_name().length(),
            ::google::protobuf::internal::WireFormat::PARSE,
            "cvar_name");
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

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

void CSVCMsg_GetCvarValue::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:CSVCMsg_GetCvarValue)
  // optional int32 cookie = 1;
  if (has_cookie()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->cookie(), output);
  }

  // optional string cvar_name = 2;
  if (has_cvar_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->cvar_name().data(), this->cvar_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "cvar_name");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      2, this->cvar_name(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:CSVCMsg_GetCvarValue)
}

::google::protobuf::uint8* CSVCMsg_GetCvarValue::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:CSVCMsg_GetCvarValue)
  // optional int32 cookie = 1;
  if (has_cookie()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->cookie(), target);
  }

  // optional string cvar_name = 2;
  if (has_cvar_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->cvar_name().data(), this->cvar_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "cvar_name");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        2, this->cvar_name(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:CSVCMsg_GetCvarValue)
  return target;
}

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional int32 cookie = 1;
    if (has_cookie()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->cookie());
    }

    // optional string cvar_name = 2;
    if (has_cvar_name()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->cvar_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 CSVCMsg_GetCvarValue::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const CSVCMsg_GetCvarValue* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const CSVCMsg_GetCvarValue*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void CSVCMsg_GetCvarValue::MergeFrom(const CSVCMsg_GetCvarValue& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_cookie()) {
      set_cookie(from.cookie());
    }
    if (from.has_cvar_name()) {
      set_cvar_name(from.cvar_name());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void CSVCMsg_GetCvarValue::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool CSVCMsg_GetCvarValue::IsInitialized() const {

  return true;
}

void CSVCMsg_GetCvarValue::Swap(CSVCMsg_GetCvarValue* other) {
  if (other != this) {
    std::swap(cookie_, other->cookie_);
    std::swap(cvar_name_, other->cvar_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 CSVCMsg_GetCvarValue::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CSVCMsg_GetCvarValue_descriptor_;
  metadata.reflection = CSVCMsg_GetCvarValue_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int CSVCMsg_Menu::kDialogTypeFieldNumber;
const int CSVCMsg_Menu::kMenuKeyValuesFieldNumber;
#endif  // !_MSC_VER

CSVCMsg_Menu::CSVCMsg_Menu()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:CSVCMsg_Menu)
}

void CSVCMsg_Menu::InitAsDefaultInstance() {
}

CSVCMsg_Menu::CSVCMsg_Menu(const CSVCMsg_Menu& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:CSVCMsg_Menu)
}

void CSVCMsg_Menu::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  dialog_type_ = 0;
  menu_key_values_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CSVCMsg_Menu::~CSVCMsg_Menu() {
  // @@protoc_insertion_point(destructor:CSVCMsg_Menu)
  SharedDtor();
}

void CSVCMsg_Menu::SharedDtor() {
  if (menu_key_values_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete menu_key_values_;
  }
  if (this != default_instance_) {
  }
}

void CSVCMsg_Menu::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CSVCMsg_Menu::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return CSVCMsg_Menu_descriptor_;
}

const CSVCMsg_Menu& CSVCMsg_Menu::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
  return *default_instance_;
}

CSVCMsg_Menu* CSVCMsg_Menu::default_instance_ = NULL;

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

void CSVCMsg_Menu::Clear() {
  if (_has_bits_[0 / 32] & 3) {
    dialog_type_ = 0;
    if (has_menu_key_values()) {
      if (menu_key_values_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        menu_key_values_->clear();
      }
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool CSVCMsg_Menu::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:CSVCMsg_Menu)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 dialog_type = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &dialog_type_)));
          set_has_dialog_type();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_menu_key_values;
        break;
      }

      // optional bytes menu_key_values = 2;
      case 2: {
        if (tag == 18) {
         parse_menu_key_values:
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_menu_key_values()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

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

void CSVCMsg_Menu::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:CSVCMsg_Menu)
  // optional int32 dialog_type = 1;
  if (has_dialog_type()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->dialog_type(), output);
  }

  // optional bytes menu_key_values = 2;
  if (has_menu_key_values()) {
    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
      2, this->menu_key_values(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:CSVCMsg_Menu)
}

::google::protobuf::uint8* CSVCMsg_Menu::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:CSVCMsg_Menu)
  // optional int32 dialog_type = 1;
  if (has_dialog_type()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->dialog_type(), target);
  }

  // optional bytes menu_key_values = 2;
  if (has_menu_key_values()) {
    target =
      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
        2, this->menu_key_values(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:CSVCMsg_Menu)
  return target;
}

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional int32 dialog_type = 1;
    if (has_dialog_type()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->dialog_type());
    }

    // optional bytes menu_key_values = 2;
    if (has_menu_key_values()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->menu_key_values());
    }

  }
  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 CSVCMsg_Menu::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const CSVCMsg_Menu* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const CSVCMsg_Menu*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void CSVCMsg_Menu::MergeFrom(const CSVCMsg_Menu& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_dialog_type()) {
      set_dialog_type(from.dialog_type());
    }
    if (from.has_menu_key_values()) {
      set_menu_key_values(from.menu_key_values());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void CSVCMsg_Menu::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool CSVCMsg_Menu::IsInitialized() const {

  return true;
}

void CSVCMsg_Menu::Swap(CSVCMsg_Menu* other) {
  if (other != this) {
    std::swap(dialog_type_, other->dialog_type_);
    std::swap(menu_key_values_, other->menu_key_values_);
    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 CSVCMsg_Menu::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CSVCMsg_Menu_descriptor_;
  metadata.reflection = CSVCMsg_Menu_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int CSVCMsg_SendTable_sendprop_t::kTypeFieldNumber;
const int CSVCMsg_SendTable_sendprop_t::kVarNameFieldNumber;
const int CSVCMsg_SendTable_sendprop_t::kFlagsFieldNumber;
const int CSVCMsg_SendTable_sendprop_t::kPriorityFieldNumber;
const int CSVCMsg_SendTable_sendprop_t::kDtNameFieldNumber;
const int CSVCMsg_SendTable_sendprop_t::kNumElementsFieldNumber;
const int CSVCMsg_SendTable_sendprop_t::kLowValueFieldNumber;
const int CSVCMsg_SendTable_sendprop_t::kHighValueFieldNumber;
const int CSVCMsg_SendTable_sendprop_t::kNumBitsFieldNumber;
#endif  // !_MSC_VER

CSVCMsg_SendTable_sendprop_t::CSVCMsg_SendTable_sendprop_t()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:CSVCMsg_SendTable.sendprop_t)
}

void CSVCMsg_SendTable_sendprop_t::InitAsDefaultInstance() {
}

CSVCMsg_SendTable_sendprop_t::CSVCMsg_SendTable_sendprop_t(const CSVCMsg_SendTable_sendprop_t& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:CSVCMsg_SendTable.sendprop_t)
}

void CSVCMsg_SendTable_sendprop_t::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  type_ = 0;
  var_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  flags_ = 0;
  priority_ = 0;
  dt_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  num_elements_ = 0;
  low_value_ = 0;
  high_value_ = 0;
  num_bits_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CSVCMsg_SendTable_sendprop_t::~CSVCMsg_SendTable_sendprop_t() {
  // @@protoc_insertion_point(destructor:CSVCMsg_SendTable.sendprop_t)
  SharedDtor();
}

void CSVCMsg_SendTable_sendprop_t::SharedDtor() {
  if (var_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete var_name_;
  }
  if (dt_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete dt_name_;
  }
  if (this != default_instance_) {
  }
}

void CSVCMsg_SendTable_sendprop_t::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CSVCMsg_SendTable_sendprop_t::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return CSVCMsg_SendTable_sendprop_t_descriptor_;
}

const CSVCMsg_SendTable_sendprop_t& CSVCMsg_SendTable_sendprop_t::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
  return *default_instance_;
}

CSVCMsg_SendTable_sendprop_t* CSVCMsg_SendTable_sendprop_t::default_instance_ = NULL;

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

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

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

  if (_has_bits_[0 / 32] & 255) {
    ZR_(type_, flags_);
    ZR_(priority_, high_value_);
    if (has_var_name()) {
      if (var_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        var_name_->clear();
      }
    }
    if (has_dt_name()) {
      if (dt_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        dt_name_->clear();
      }
    }
  }
  num_bits_ = 0;

#undef OFFSET_OF_FIELD_
#undef ZR_

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

bool CSVCMsg_SendTable_sendprop_t::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:CSVCMsg_SendTable.sendprop_t)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 type = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &type_)));
          set_has_type();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_var_name;
        break;
      }

      // optional string var_name = 2;
      case 2: {
        if (tag == 18) {
         parse_var_name:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_var_name()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->var_name().data(), this->var_name().length(),
            ::google::protobuf::internal::WireFormat::PARSE,
            "var_name");
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_flags;
        break;
      }

      // optional int32 flags = 3;
      case 3: {
        if (tag == 24) {
         parse_flags:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &flags_)));
          set_has_flags();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(32)) goto parse_priority;
        break;
      }

      // optional int32 priority = 4;
      case 4: {
        if (tag == 32) {
         parse_priority:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &priority_)));
          set_has_priority();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(42)) goto parse_dt_name;
        break;
      }

      // optional string dt_name = 5;
      case 5: {
        if (tag == 42) {
         parse_dt_name:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_dt_name()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->dt_name().data(), this->dt_name().length(),
            ::google::protobuf::internal::WireFormat::PARSE,
            "dt_name");
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(48)) goto parse_num_elements;
        break;
      }

      // optional int32 num_elements = 6;
      case 6: {
        if (tag == 48) {
         parse_num_elements:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &num_elements_)));
          set_has_num_elements();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(61)) goto parse_low_value;
        break;
      }

      // optional float low_value = 7;
      case 7: {
        if (tag == 61) {
         parse_low_value:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &low_value_)));
          set_has_low_value();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(69)) goto parse_high_value;
        break;
      }

      // optional float high_value = 8;
      case 8: {
        if (tag == 69) {
         parse_high_value:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &high_value_)));
          set_has_high_value();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(72)) goto parse_num_bits;
        break;
      }

      // optional int32 num_bits = 9;
      case 9: {
        if (tag == 72) {
         parse_num_bits:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &num_bits_)));
          set_has_num_bits();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

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

void CSVCMsg_SendTable_sendprop_t::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:CSVCMsg_SendTable.sendprop_t)
  // optional int32 type = 1;
  if (has_type()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->type(), output);
  }

  // optional string var_name = 2;
  if (has_var_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->var_name().data(), this->var_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "var_name");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      2, this->var_name(), output);
  }

  // optional int32 flags = 3;
  if (has_flags()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->flags(), output);
  }

  // optional int32 priority = 4;
  if (has_priority()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->priority(), output);
  }

  // optional string dt_name = 5;
  if (has_dt_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->dt_name().data(), this->dt_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "dt_name");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      5, this->dt_name(), output);
  }

  // optional int32 num_elements = 6;
  if (has_num_elements()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(6, this->num_elements(), output);
  }

  // optional float low_value = 7;
  if (has_low_value()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(7, this->low_value(), output);
  }

  // optional float high_value = 8;
  if (has_high_value()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(8, this->high_value(), output);
  }

  // optional int32 num_bits = 9;
  if (has_num_bits()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(9, this->num_bits(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:CSVCMsg_SendTable.sendprop_t)
}

::google::protobuf::uint8* CSVCMsg_SendTable_sendprop_t::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:CSVCMsg_SendTable.sendprop_t)
  // optional int32 type = 1;
  if (has_type()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->type(), target);
  }

  // optional string var_name = 2;
  if (has_var_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->var_name().data(), this->var_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "var_name");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        2, this->var_name(), target);
  }

  // optional int32 flags = 3;
  if (has_flags()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->flags(), target);
  }

  // optional int32 priority = 4;
  if (has_priority()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(4, this->priority(), target);
  }

  // optional string dt_name = 5;
  if (has_dt_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->dt_name().data(), this->dt_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "dt_name");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        5, this->dt_name(), target);
  }

  // optional int32 num_elements = 6;
  if (has_num_elements()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(6, this->num_elements(), target);
  }

  // optional float low_value = 7;
  if (has_low_value()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(7, this->low_value(), target);
  }

  // optional float high_value = 8;
  if (has_high_value()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(8, this->high_value(), target);
  }

  // optional int32 num_bits = 9;
  if (has_num_bits()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(9, this->num_bits(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:CSVCMsg_SendTable.sendprop_t)
  return target;
}

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional int32 type = 1;
    if (has_type()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->type());
    }

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

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

    // optional int32 priority = 4;
    if (has_priority()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->priority());
    }

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

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

    // optional float low_value = 7;
    if (has_low_value()) {
      total_size += 1 + 4;
    }

    // optional float high_value = 8;
    if (has_high_value()) {
      total_size += 1 + 4;
    }

  }
  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
    // optional int32 num_bits = 9;
    if (has_num_bits()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->num_bits());
    }

  }
  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 CSVCMsg_SendTable_sendprop_t::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const CSVCMsg_SendTable_sendprop_t* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const CSVCMsg_SendTable_sendprop_t*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void CSVCMsg_SendTable_sendprop_t::MergeFrom(const CSVCMsg_SendTable_sendprop_t& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_type()) {
      set_type(from.type());
    }
    if (from.has_var_name()) {
      set_var_name(from.var_name());
    }
    if (from.has_flags()) {
      set_flags(from.flags());
    }
    if (from.has_priority()) {
      set_priority(from.priority());
    }
    if (from.has_dt_name()) {
      set_dt_name(from.dt_name());
    }
    if (from.has_num_elements()) {
      set_num_elements(from.num_elements());
    }
    if (from.has_low_value()) {
      set_low_value(from.low_value());
    }
    if (from.has_high_value()) {
      set_high_value(from.high_value());
    }
  }
  if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
    if (from.has_num_bits()) {
      set_num_bits(from.num_bits());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void CSVCMsg_SendTable_sendprop_t::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool CSVCMsg_SendTable_sendprop_t::IsInitialized() const {

  return true;
}

void CSVCMsg_SendTable_sendprop_t::Swap(CSVCMsg_SendTable_sendprop_t* other) {
  if (other != this) {
    std::swap(type_, other->type_);
    std::swap(var_name_, other->var_name_);
    std::swap(flags_, other->flags_);
    std::swap(priority_, other->priority_);
    std::swap(dt_name_, other->dt_name_);
    std::swap(num_elements_, other->num_elements_);
    std::swap(low_value_, other->low_value_);
    std::swap(high_value_, other->high_value_);
    std::swap(num_bits_, other->num_bits_);
    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 CSVCMsg_SendTable_sendprop_t::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CSVCMsg_SendTable_sendprop_t_descriptor_;
  metadata.reflection = CSVCMsg_SendTable_sendprop_t_reflection_;
  return metadata;
}


// -------------------------------------------------------------------

#ifndef _MSC_VER
const int CSVCMsg_SendTable::kIsEndFieldNumber;
const int CSVCMsg_SendTable::kNetTableNameFieldNumber;
const int CSVCMsg_SendTable::kNeedsDecoderFieldNumber;
const int CSVCMsg_SendTable::kPropsFieldNumber;
#endif  // !_MSC_VER

CSVCMsg_SendTable::CSVCMsg_SendTable()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:CSVCMsg_SendTable)
}

void CSVCMsg_SendTable::InitAsDefaultInstance() {
}

CSVCMsg_SendTable::CSVCMsg_SendTable(const CSVCMsg_SendTable& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:CSVCMsg_SendTable)
}

void CSVCMsg_SendTable::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  is_end_ = false;
  net_table_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  needs_decoder_ = false;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CSVCMsg_SendTable::~CSVCMsg_SendTable() {
  // @@protoc_insertion_point(destructor:CSVCMsg_SendTable)
  SharedDtor();
}

void CSVCMsg_SendTable::SharedDtor() {
  if (net_table_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete net_table_name_;
  }
  if (this != default_instance_) {
  }
}

void CSVCMsg_SendTable::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CSVCMsg_SendTable::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return CSVCMsg_SendTable_descriptor_;
}

const CSVCMsg_SendTable& CSVCMsg_SendTable::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
  return *default_instance_;
}

CSVCMsg_SendTable* CSVCMsg_SendTable::default_instance_ = NULL;

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

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

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

  if (_has_bits_[0 / 32] & 7) {
    ZR_(is_end_, needs_decoder_);
    if (has_net_table_name()) {
      if (net_table_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        net_table_name_->clear();
      }
    }
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

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

bool CSVCMsg_SendTable::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:CSVCMsg_SendTable)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional bool is_end = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &is_end_)));
          set_has_is_end();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_net_table_name;
        break;
      }

      // optional string net_table_name = 2;
      case 2: {
        if (tag == 18) {
         parse_net_table_name:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_net_table_name()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->net_table_name().data(), this->net_table_name().length(),
            ::google::protobuf::internal::WireFormat::PARSE,
            "net_table_name");
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_needs_decoder;
        break;
      }

      // optional bool needs_decoder = 3;
      case 3: {
        if (tag == 24) {
         parse_needs_decoder:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &needs_decoder_)));
          set_has_needs_decoder();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(34)) goto parse_props;
        break;
      }

      // repeated .CSVCMsg_SendTable.sendprop_t props = 4;
      case 4: {
        if (tag == 34) {
         parse_props:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_props()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(34)) goto parse_props;
        if (input->ExpectAtEnd()) goto success;
        break;
      }

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

void CSVCMsg_SendTable::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:CSVCMsg_SendTable)
  // optional bool is_end = 1;
  if (has_is_end()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->is_end(), output);
  }

  // optional string net_table_name = 2;
  if (has_net_table_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->net_table_name().data(), this->net_table_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "net_table_name");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      2, this->net_table_name(), output);
  }

  // optional bool needs_decoder = 3;
  if (has_needs_decoder()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->needs_decoder(), output);
  }

  // repeated .CSVCMsg_SendTable.sendprop_t props = 4;
  for (int i = 0; i < this->props_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      4, this->props(i), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:CSVCMsg_SendTable)
}

::google::protobuf::uint8* CSVCMsg_SendTable::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:CSVCMsg_SendTable)
  // optional bool is_end = 1;
  if (has_is_end()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(1, this->is_end(), target);
  }

  // optional string net_table_name = 2;
  if (has_net_table_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->net_table_name().data(), this->net_table_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "net_table_name");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        2, this->net_table_name(), target);
  }

  // optional bool needs_decoder = 3;
  if (has_needs_decoder()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->needs_decoder(), target);
  }

  // repeated .CSVCMsg_SendTable.sendprop_t props = 4;
  for (int i = 0; i < this->props_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        4, this->props(i), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:CSVCMsg_SendTable)
  return target;
}

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional bool is_end = 1;
    if (has_is_end()) {
      total_size += 1 + 1;
    }

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

    // optional bool needs_decoder = 3;
    if (has_needs_decoder()) {
      total_size += 1 + 1;
    }

  }
  // repeated .CSVCMsg_SendTable.sendprop_t props = 4;
  total_size += 1 * this->props_size();
  for (int i = 0; i < this->props_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->props(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 CSVCMsg_SendTable::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const CSVCMsg_SendTable* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const CSVCMsg_SendTable*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void CSVCMsg_SendTable::MergeFrom(const CSVCMsg_SendTable& from) {
  GOOGLE_CHECK_NE(&from, this);
  props_.MergeFrom(from.props_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_is_end()) {
      set_is_end(from.is_end());
    }
    if (from.has_net_table_name()) {
      set_net_table_name(from.net_table_name());
    }
    if (from.has_needs_decoder()) {
      set_needs_decoder(from.needs_decoder());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void CSVCMsg_SendTable::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool CSVCMsg_SendTable::IsInitialized() const {

  return true;
}

void CSVCMsg_SendTable::Swap(CSVCMsg_SendTable* other) {
  if (other != this) {
    std::swap(is_end_, other->is_end_);
    std::swap(net_table_name_, other->net_table_name_);
    std::swap(needs_decoder_, other->needs_decoder_);
    props_.Swap(&other->props_);
    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 CSVCMsg_SendTable::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CSVCMsg_SendTable_descriptor_;
  metadata.reflection = CSVCMsg_SendTable_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int CSVCMsg_GameEventList_key_t::kTypeFieldNumber;
const int CSVCMsg_GameEventList_key_t::kNameFieldNumber;
#endif  // !_MSC_VER

CSVCMsg_GameEventList_key_t::CSVCMsg_GameEventList_key_t()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:CSVCMsg_GameEventList.key_t)
}

void CSVCMsg_GameEventList_key_t::InitAsDefaultInstance() {
}

CSVCMsg_GameEventList_key_t::CSVCMsg_GameEventList_key_t(const CSVCMsg_GameEventList_key_t& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:CSVCMsg_GameEventList.key_t)
}

void CSVCMsg_GameEventList_key_t::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  type_ = 0;
  name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CSVCMsg_GameEventList_key_t::~CSVCMsg_GameEventList_key_t() {
  // @@protoc_insertion_point(destructor:CSVCMsg_GameEventList.key_t)
  SharedDtor();
}

void CSVCMsg_GameEventList_key_t::SharedDtor() {
  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete name_;
  }
  if (this != default_instance_) {
  }
}

void CSVCMsg_GameEventList_key_t::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CSVCMsg_GameEventList_key_t::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return CSVCMsg_GameEventList_key_t_descriptor_;
}

const CSVCMsg_GameEventList_key_t& CSVCMsg_GameEventList_key_t::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
  return *default_instance_;
}

CSVCMsg_GameEventList_key_t* CSVCMsg_GameEventList_key_t::default_instance_ = NULL;

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

void CSVCMsg_GameEventList_key_t::Clear() {
  if (_has_bits_[0 / 32] & 3) {
    type_ = 0;
    if (has_name()) {
      if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        name_->clear();
      }
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool CSVCMsg_GameEventList_key_t::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:CSVCMsg_GameEventList.key_t)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 type = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &type_)));
          set_has_type();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_name;
        break;
      }

      // optional string name = 2;
      case 2: {
        if (tag == 18) {
         parse_name:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_name()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->name().data(), this->name().length(),
            ::google::protobuf::internal::WireFormat::PARSE,
            "name");
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

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

void CSVCMsg_GameEventList_key_t::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:CSVCMsg_GameEventList.key_t)
  // optional int32 type = 1;
  if (has_type()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->type(), output);
  }

  // optional string name = 2;
  if (has_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->name().data(), this->name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "name");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      2, this->name(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:CSVCMsg_GameEventList.key_t)
}

::google::protobuf::uint8* CSVCMsg_GameEventList_key_t::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:CSVCMsg_GameEventList.key_t)
  // optional int32 type = 1;
  if (has_type()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->type(), target);
  }

  // optional string name = 2;
  if (has_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->name().data(), this->name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "name");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        2, this->name(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:CSVCMsg_GameEventList.key_t)
  return target;
}

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional int32 type = 1;
    if (has_type()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->type());
    }

    // optional string name = 2;
    if (has_name()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->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 CSVCMsg_GameEventList_key_t::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const CSVCMsg_GameEventList_key_t* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const CSVCMsg_GameEventList_key_t*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void CSVCMsg_GameEventList_key_t::MergeFrom(const CSVCMsg_GameEventList_key_t& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_type()) {
      set_type(from.type());
    }
    if (from.has_name()) {
      set_name(from.name());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void CSVCMsg_GameEventList_key_t::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool CSVCMsg_GameEventList_key_t::IsInitialized() const {

  return true;
}

void CSVCMsg_GameEventList_key_t::Swap(CSVCMsg_GameEventList_key_t* other) {
  if (other != this) {
    std::swap(type_, other->type_);
    std::swap(name_, other->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 CSVCMsg_GameEventList_key_t::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CSVCMsg_GameEventList_key_t_descriptor_;
  metadata.reflection = CSVCMsg_GameEventList_key_t_reflection_;
  return metadata;
}


// -------------------------------------------------------------------

#ifndef _MSC_VER
const int CSVCMsg_GameEventList_descriptor_t::kEventidFieldNumber;
const int CSVCMsg_GameEventList_descriptor_t::kNameFieldNumber;
const int CSVCMsg_GameEventList_descriptor_t::kKeysFieldNumber;
#endif  // !_MSC_VER

CSVCMsg_GameEventList_descriptor_t::CSVCMsg_GameEventList_descriptor_t()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:CSVCMsg_GameEventList.descriptor_t)
}

void CSVCMsg_GameEventList_descriptor_t::InitAsDefaultInstance() {
}

CSVCMsg_GameEventList_descriptor_t::CSVCMsg_GameEventList_descriptor_t(const CSVCMsg_GameEventList_descriptor_t& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:CSVCMsg_GameEventList.descriptor_t)
}

void CSVCMsg_GameEventList_descriptor_t::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  eventid_ = 0;
  name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CSVCMsg_GameEventList_descriptor_t::~CSVCMsg_GameEventList_descriptor_t() {
  // @@protoc_insertion_point(destructor:CSVCMsg_GameEventList.descriptor_t)
  SharedDtor();
}

void CSVCMsg_GameEventList_descriptor_t::SharedDtor() {
  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete name_;
  }
  if (this != default_instance_) {
  }
}

void CSVCMsg_GameEventList_descriptor_t::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CSVCMsg_GameEventList_descriptor_t::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return CSVCMsg_GameEventList_descriptor_t_descriptor_;
}

const CSVCMsg_GameEventList_descriptor_t& CSVCMsg_GameEventList_descriptor_t::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
  return *default_instance_;
}

CSVCMsg_GameEventList_descriptor_t* CSVCMsg_GameEventList_descriptor_t::default_instance_ = NULL;

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

void CSVCMsg_GameEventList_descriptor_t::Clear() {
  if (_has_bits_[0 / 32] & 3) {
    eventid_ = 0;
    if (has_name()) {
      if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        name_->clear();
      }
    }
  }
  keys_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool CSVCMsg_GameEventList_descriptor_t::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:CSVCMsg_GameEventList.descriptor_t)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 eventid = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &eventid_)));
          set_has_eventid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_name;
        break;
      }

      // optional string name = 2;
      case 2: {
        if (tag == 18) {
         parse_name:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_name()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->name().data(), this->name().length(),
            ::google::protobuf::internal::WireFormat::PARSE,
            "name");
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_keys;
        break;
      }

      // repeated .CSVCMsg_GameEventList.key_t keys = 3;
      case 3: {
        if (tag == 26) {
         parse_keys:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_keys()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_keys;
        if (input->ExpectAtEnd()) goto success;
        break;
      }

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

void CSVCMsg_GameEventList_descriptor_t::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:CSVCMsg_GameEventList.descriptor_t)
  // optional int32 eventid = 1;
  if (has_eventid()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->eventid(), output);
  }

  // optional string name = 2;
  if (has_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->name().data(), this->name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "name");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      2, this->name(), output);
  }

  // repeated .CSVCMsg_GameEventList.key_t keys = 3;
  for (int i = 0; i < this->keys_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      3, this->keys(i), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:CSVCMsg_GameEventList.descriptor_t)
}

::google::protobuf::uint8* CSVCMsg_GameEventList_descriptor_t::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:CSVCMsg_GameEventList.descriptor_t)
  // optional int32 eventid = 1;
  if (has_eventid()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->eventid(), target);
  }

  // optional string name = 2;
  if (has_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->name().data(), this->name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "name");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        2, this->name(), target);
  }

  // repeated .CSVCMsg_GameEventList.key_t keys = 3;
  for (int i = 0; i < this->keys_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        3, this->keys(i), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:CSVCMsg_GameEventList.descriptor_t)
  return target;
}

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional int32 eventid = 1;
    if (has_eventid()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->eventid());
    }

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

  }
  // repeated .CSVCMsg_GameEventList.key_t keys = 3;
  total_size += 1 * this->keys_size();
  for (int i = 0; i < this->keys_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->keys(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 CSVCMsg_GameEventList_descriptor_t::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const CSVCMsg_GameEventList_descriptor_t* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const CSVCMsg_GameEventList_descriptor_t*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void CSVCMsg_GameEventList_descriptor_t::MergeFrom(const CSVCMsg_GameEventList_descriptor_t& from) {
  GOOGLE_CHECK_NE(&from, this);
  keys_.MergeFrom(from.keys_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_eventid()) {
      set_eventid(from.eventid());
    }
    if (from.has_name()) {
      set_name(from.name());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void CSVCMsg_GameEventList_descriptor_t::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool CSVCMsg_GameEventList_descriptor_t::IsInitialized() const {

  return true;
}

void CSVCMsg_GameEventList_descriptor_t::Swap(CSVCMsg_GameEventList_descriptor_t* other) {
  if (other != this) {
    std::swap(eventid_, other->eventid_);
    std::swap(name_, other->name_);
    keys_.Swap(&other->keys_);
    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 CSVCMsg_GameEventList_descriptor_t::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CSVCMsg_GameEventList_descriptor_t_descriptor_;
  metadata.reflection = CSVCMsg_GameEventList_descriptor_t_reflection_;
  return metadata;
}


// -------------------------------------------------------------------

#ifndef _MSC_VER
const int CSVCMsg_GameEventList::kDescriptorsFieldNumber;
#endif  // !_MSC_VER

CSVCMsg_GameEventList::CSVCMsg_GameEventList()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:CSVCMsg_GameEventList)
}

void CSVCMsg_GameEventList::InitAsDefaultInstance() {
}

CSVCMsg_GameEventList::CSVCMsg_GameEventList(const CSVCMsg_GameEventList& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:CSVCMsg_GameEventList)
}

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

CSVCMsg_GameEventList::~CSVCMsg_GameEventList() {
  // @@protoc_insertion_point(destructor:CSVCMsg_GameEventList)
  SharedDtor();
}

void CSVCMsg_GameEventList::SharedDtor() {
  if (this != default_instance_) {
  }
}

void CSVCMsg_GameEventList::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CSVCMsg_GameEventList::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return CSVCMsg_GameEventList_descriptor_;
}

const CSVCMsg_GameEventList& CSVCMsg_GameEventList::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
  return *default_instance_;
}

CSVCMsg_GameEventList* CSVCMsg_GameEventList::default_instance_ = NULL;

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

void CSVCMsg_GameEventList::Clear() {
  descriptors_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool CSVCMsg_GameEventList::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:CSVCMsg_GameEventList)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // repeated .CSVCMsg_GameEventList.descriptor_t descriptors = 1;
      case 1: {
        if (tag == 10) {
         parse_descriptors:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_descriptors()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(10)) goto parse_descriptors;
        if (input->ExpectAtEnd()) goto success;
        break;
      }

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

void CSVCMsg_GameEventList::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:CSVCMsg_GameEventList)
  // repeated .CSVCMsg_GameEventList.descriptor_t descriptors = 1;
  for (int i = 0; i < this->descriptors_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->descriptors(i), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:CSVCMsg_GameEventList)
}

::google::protobuf::uint8* CSVCMsg_GameEventList::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:CSVCMsg_GameEventList)
  // repeated .CSVCMsg_GameEventList.descriptor_t descriptors = 1;
  for (int i = 0; i < this->descriptors_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->descriptors(i), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:CSVCMsg_GameEventList)
  return target;
}

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

  // repeated .CSVCMsg_GameEventList.descriptor_t descriptors = 1;
  total_size += 1 * this->descriptors_size();
  for (int i = 0; i < this->descriptors_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->descriptors(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 CSVCMsg_GameEventList::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const CSVCMsg_GameEventList* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const CSVCMsg_GameEventList*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

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

void CSVCMsg_GameEventList::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool CSVCMsg_GameEventList::IsInitialized() const {

  return true;
}

void CSVCMsg_GameEventList::Swap(CSVCMsg_GameEventList* other) {
  if (other != this) {
    descriptors_.Swap(&other->descriptors_);
    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 CSVCMsg_GameEventList::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CSVCMsg_GameEventList_descriptor_;
  metadata.reflection = CSVCMsg_GameEventList_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int CSVCMsg_PacketEntities::kMaxEntriesFieldNumber;
const int CSVCMsg_PacketEntities::kUpdatedEntriesFieldNumber;
const int CSVCMsg_PacketEntities::kIsDeltaFieldNumber;
const int CSVCMsg_PacketEntities::kUpdateBaselineFieldNumber;
const int CSVCMsg_PacketEntities::kBaselineFieldNumber;
const int CSVCMsg_PacketEntities::kDeltaFromFieldNumber;
const int CSVCMsg_PacketEntities::kEntityDataFieldNumber;
const int CSVCMsg_PacketEntities::kPendingFullFrameFieldNumber;
const int CSVCMsg_PacketEntities::kActiveSpawngroupHandleFieldNumber;
const int CSVCMsg_PacketEntities::kMaxSpawngroupCreationsequenceFieldNumber;
#endif  // !_MSC_VER

CSVCMsg_PacketEntities::CSVCMsg_PacketEntities()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:CSVCMsg_PacketEntities)
}

void CSVCMsg_PacketEntities::InitAsDefaultInstance() {
}

CSVCMsg_PacketEntities::CSVCMsg_PacketEntities(const CSVCMsg_PacketEntities& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:CSVCMsg_PacketEntities)
}

void CSVCMsg_PacketEntities::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  max_entries_ = 0;
  updated_entries_ = 0;
  is_delta_ = false;
  update_baseline_ = false;
  baseline_ = 0;
  delta_from_ = 0;
  entity_data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  pending_full_frame_ = false;
  active_spawngroup_handle_ = 0u;
  max_spawngroup_creationsequence_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CSVCMsg_PacketEntities::~CSVCMsg_PacketEntities() {
  // @@protoc_insertion_point(destructor:CSVCMsg_PacketEntities)
  SharedDtor();
}

void CSVCMsg_PacketEntities::SharedDtor() {
  if (entity_data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete entity_data_;
  }
  if (this != default_instance_) {
  }
}

void CSVCMsg_PacketEntities::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CSVCMsg_PacketEntities::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return CSVCMsg_PacketEntities_descriptor_;
}

const CSVCMsg_PacketEntities& CSVCMsg_PacketEntities::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
  return *default_instance_;
}

CSVCMsg_PacketEntities* CSVCMsg_PacketEntities::default_instance_ = NULL;

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

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

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

  if (_has_bits_[0 / 32] & 255) {
    ZR_(max_entries_, pending_full_frame_);
    delta_from_ = 0;
    if (has_entity_data()) {
      if (entity_data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        entity_data_->clear();
      }
    }
  }
  ZR_(active_spawngroup_handle_, max_spawngroup_creationsequence_);

#undef OFFSET_OF_FIELD_
#undef ZR_

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

bool CSVCMsg_PacketEntities::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:CSVCMsg_PacketEntities)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 max_entries = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &max_entries_)));
          set_has_max_entries();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_updated_entries;
        break;
      }

      // optional int32 updated_entries = 2;
      case 2: {
        if (tag == 16) {
         parse_updated_entries:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &updated_entries_)));
          set_has_updated_entries();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_is_delta;
        break;
      }

      // optional bool is_delta = 3;
      case 3: {
        if (tag == 24) {
         parse_is_delta:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &is_delta_)));
          set_has_is_delta();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(32)) goto parse_update_baseline;
        break;
      }

      // optional bool update_baseline = 4;
      case 4: {
        if (tag == 32) {
         parse_update_baseline:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &update_baseline_)));
          set_has_update_baseline();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(40)) goto parse_baseline;
        break;
      }

      // optional int32 baseline = 5;
      case 5: {
        if (tag == 40) {
         parse_baseline:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &baseline_)));
          set_has_baseline();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(48)) goto parse_delta_from;
        break;
      }

      // optional int32 delta_from = 6;
      case 6: {
        if (tag == 48) {
         parse_delta_from:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &delta_from_)));
          set_has_delta_from();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(58)) goto parse_entity_data;
        break;
      }

      // optional bytes entity_data = 7;
      case 7: {
        if (tag == 58) {
         parse_entity_data:
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_entity_data()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(64)) goto parse_pending_full_frame;
        break;
      }

      // optional bool pending_full_frame = 8;
      case 8: {
        if (tag == 64) {
         parse_pending_full_frame:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &pending_full_frame_)));
          set_has_pending_full_frame();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(72)) goto parse_active_spawngroup_handle;
        break;
      }

      // optional uint32 active_spawngroup_handle = 9;
      case 9: {
        if (tag == 72) {
         parse_active_spawngroup_handle:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &active_spawngroup_handle_)));
          set_has_active_spawngroup_handle();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(80)) goto parse_max_spawngroup_creationsequence;
        break;
      }

      // optional uint32 max_spawngroup_creationsequence = 10;
      case 10: {
        if (tag == 80) {
         parse_max_spawngroup_creationsequence:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &max_spawngroup_creationsequence_)));
          set_has_max_spawngroup_creationsequence();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

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

void CSVCMsg_PacketEntities::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:CSVCMsg_PacketEntities)
  // optional int32 max_entries = 1;
  if (has_max_entries()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->max_entries(), output);
  }

  // optional int32 updated_entries = 2;
  if (has_updated_entries()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->updated_entries(), output);
  }

  // optional bool is_delta = 3;
  if (has_is_delta()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->is_delta(), output);
  }

  // optional bool update_baseline = 4;
  if (has_update_baseline()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->update_baseline(), output);
  }

  // optional int32 baseline = 5;
  if (has_baseline()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(5, this->baseline(), output);
  }

  // optional int32 delta_from = 6;
  if (has_delta_from()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(6, this->delta_from(), output);
  }

  // optional bytes entity_data = 7;
  if (has_entity_data()) {
    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
      7, this->entity_data(), output);
  }

  // optional bool pending_full_frame = 8;
  if (has_pending_full_frame()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(8, this->pending_full_frame(), output);
  }

  // optional uint32 active_spawngroup_handle = 9;
  if (has_active_spawngroup_handle()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(9, this->active_spawngroup_handle(), output);
  }

  // optional uint32 max_spawngroup_creationsequence = 10;
  if (has_max_spawngroup_creationsequence()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(10, this->max_spawngroup_creationsequence(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:CSVCMsg_PacketEntities)
}

::google::protobuf::uint8* CSVCMsg_PacketEntities::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:CSVCMsg_PacketEntities)
  // optional int32 max_entries = 1;
  if (has_max_entries()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->max_entries(), target);
  }

  // optional int32 updated_entries = 2;
  if (has_updated_entries()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->updated_entries(), target);
  }

  // optional bool is_delta = 3;
  if (has_is_delta()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->is_delta(), target);
  }

  // optional bool update_baseline = 4;
  if (has_update_baseline()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(4, this->update_baseline(), target);
  }

  // optional int32 baseline = 5;
  if (has_baseline()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(5, this->baseline(), target);
  }

  // optional int32 delta_from = 6;
  if (has_delta_from()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(6, this->delta_from(), target);
  }

  // optional bytes entity_data = 7;
  if (has_entity_data()) {
    target =
      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
        7, this->entity_data(), target);
  }

  // optional bool pending_full_frame = 8;
  if (has_pending_full_frame()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(8, this->pending_full_frame(), target);
  }

  // optional uint32 active_spawngroup_handle = 9;
  if (has_active_spawngroup_handle()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(9, this->active_spawngroup_handle(), target);
  }

  // optional uint32 max_spawngroup_creationsequence = 10;
  if (has_max_spawngroup_creationsequence()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(10, this->max_spawngroup_creationsequence(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:CSVCMsg_PacketEntities)
  return target;
}

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional int32 max_entries = 1;
    if (has_max_entries()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->max_entries());
    }

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

    // optional bool is_delta = 3;
    if (has_is_delta()) {
      total_size += 1 + 1;
    }

    // optional bool update_baseline = 4;
    if (has_update_baseline()) {
      total_size += 1 + 1;
    }

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

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

    // optional bytes entity_data = 7;
    if (has_entity_data()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->entity_data());
    }

    // optional bool pending_full_frame = 8;
    if (has_pending_full_frame()) {
      total_size += 1 + 1;
    }

  }
  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
    // optional uint32 active_spawngroup_handle = 9;
    if (has_active_spawngroup_handle()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->active_spawngroup_handle());
    }

    // optional uint32 max_spawngroup_creationsequence = 10;
    if (has_max_spawngroup_creationsequence()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->max_spawngroup_creationsequence());
    }

  }
  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 CSVCMsg_PacketEntities::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const CSVCMsg_PacketEntities* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const CSVCMsg_PacketEntities*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void CSVCMsg_PacketEntities::MergeFrom(const CSVCMsg_PacketEntities& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_max_entries()) {
      set_max_entries(from.max_entries());
    }
    if (from.has_updated_entries()) {
      set_updated_entries(from.updated_entries());
    }
    if (from.has_is_delta()) {
      set_is_delta(from.is_delta());
    }
    if (from.has_update_baseline()) {
      set_update_baseline(from.update_baseline());
    }
    if (from.has_baseline()) {
      set_baseline(from.baseline());
    }
    if (from.has_delta_from()) {
      set_delta_from(from.delta_from());
    }
    if (from.has_entity_data()) {
      set_entity_data(from.entity_data());
    }
    if (from.has_pending_full_frame()) {
      set_pending_full_frame(from.pending_full_frame());
    }
  }
  if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
    if (from.has_active_spawngroup_handle()) {
      set_active_spawngroup_handle(from.active_spawngroup_handle());
    }
    if (from.has_max_spawngroup_creationsequence()) {
      set_max_spawngroup_creationsequence(from.max_spawngroup_creationsequence());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void CSVCMsg_PacketEntities::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool CSVCMsg_PacketEntities::IsInitialized() const {

  return true;
}

void CSVCMsg_PacketEntities::Swap(CSVCMsg_PacketEntities* other) {
  if (other != this) {
    std::swap(max_entries_, other->max_entries_);
    std::swap(updated_entries_, other->updated_entries_);
    std::swap(is_delta_, other->is_delta_);
    std::swap(update_baseline_, other->update_baseline_);
    std::swap(baseline_, other->baseline_);
    std::swap(delta_from_, other->delta_from_);
    std::swap(entity_data_, other->entity_data_);
    std::swap(pending_full_frame_, other->pending_full_frame_);
    std::swap(active_spawngroup_handle_, other->active_spawngroup_handle_);
    std::swap(max_spawngroup_creationsequence_, other->max_spawngroup_creationsequence_);
    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 CSVCMsg_PacketEntities::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CSVCMsg_PacketEntities_descriptor_;
  metadata.reflection = CSVCMsg_PacketEntities_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int CSVCMsg_TempEntities::kReliableFieldNumber;
const int CSVCMsg_TempEntities::kNumEntriesFieldNumber;
const int CSVCMsg_TempEntities::kEntityDataFieldNumber;
#endif  // !_MSC_VER

CSVCMsg_TempEntities::CSVCMsg_TempEntities()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:CSVCMsg_TempEntities)
}

void CSVCMsg_TempEntities::InitAsDefaultInstance() {
}

CSVCMsg_TempEntities::CSVCMsg_TempEntities(const CSVCMsg_TempEntities& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:CSVCMsg_TempEntities)
}

void CSVCMsg_TempEntities::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  reliable_ = false;
  num_entries_ = 0;
  entity_data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CSVCMsg_TempEntities::~CSVCMsg_TempEntities() {
  // @@protoc_insertion_point(destructor:CSVCMsg_TempEntities)
  SharedDtor();
}

void CSVCMsg_TempEntities::SharedDtor() {
  if (entity_data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete entity_data_;
  }
  if (this != default_instance_) {
  }
}

void CSVCMsg_TempEntities::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CSVCMsg_TempEntities::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return CSVCMsg_TempEntities_descriptor_;
}

const CSVCMsg_TempEntities& CSVCMsg_TempEntities::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
  return *default_instance_;
}

CSVCMsg_TempEntities* CSVCMsg_TempEntities::default_instance_ = NULL;

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

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

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

  if (_has_bits_[0 / 32] & 7) {
    ZR_(reliable_, num_entries_);
    if (has_entity_data()) {
      if (entity_data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        entity_data_->clear();
      }
    }
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

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

bool CSVCMsg_TempEntities::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:CSVCMsg_TempEntities)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional bool reliable = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &reliable_)));
          set_has_reliable();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_num_entries;
        break;
      }

      // optional int32 num_entries = 2;
      case 2: {
        if (tag == 16) {
         parse_num_entries:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &num_entries_)));
          set_has_num_entries();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_entity_data;
        break;
      }

      // optional bytes entity_data = 3;
      case 3: {
        if (tag == 26) {
         parse_entity_data:
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_entity_data()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

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

void CSVCMsg_TempEntities::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:CSVCMsg_TempEntities)
  // optional bool reliable = 1;
  if (has_reliable()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->reliable(), output);
  }

  // optional int32 num_entries = 2;
  if (has_num_entries()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->num_entries(), output);
  }

  // optional bytes entity_data = 3;
  if (has_entity_data()) {
    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
      3, this->entity_data(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:CSVCMsg_TempEntities)
}

::google::protobuf::uint8* CSVCMsg_TempEntities::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:CSVCMsg_TempEntities)
  // optional bool reliable = 1;
  if (has_reliable()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(1, this->reliable(), target);
  }

  // optional int32 num_entries = 2;
  if (has_num_entries()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->num_entries(), target);
  }

  // optional bytes entity_data = 3;
  if (has_entity_data()) {
    target =
      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
        3, this->entity_data(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:CSVCMsg_TempEntities)
  return target;
}

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional bool reliable = 1;
    if (has_reliable()) {
      total_size += 1 + 1;
    }

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

    // optional bytes entity_data = 3;
    if (has_entity_data()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->entity_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 CSVCMsg_TempEntities::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const CSVCMsg_TempEntities* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const CSVCMsg_TempEntities*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void CSVCMsg_TempEntities::MergeFrom(const CSVCMsg_TempEntities& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_reliable()) {
      set_reliable(from.reliable());
    }
    if (from.has_num_entries()) {
      set_num_entries(from.num_entries());
    }
    if (from.has_entity_data()) {
      set_entity_data(from.entity_data());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void CSVCMsg_TempEntities::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool CSVCMsg_TempEntities::IsInitialized() const {

  return true;
}

void CSVCMsg_TempEntities::Swap(CSVCMsg_TempEntities* other) {
  if (other != this) {
    std::swap(reliable_, other->reliable_);
    std::swap(num_entries_, other->num_entries_);
    std::swap(entity_data_, other->entity_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 CSVCMsg_TempEntities::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CSVCMsg_TempEntities_descriptor_;
  metadata.reflection = CSVCMsg_TempEntities_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int CSVCMsg_CreateStringTable::kNameFieldNumber;
const int CSVCMsg_CreateStringTable::kNumEntriesFieldNumber;
const int CSVCMsg_CreateStringTable::kUserDataFixedSizeFieldNumber;
const int CSVCMsg_CreateStringTable::kUserDataSizeFieldNumber;
const int CSVCMsg_CreateStringTable::kUserDataSizeBitsFieldNumber;
const int CSVCMsg_CreateStringTable::kFlagsFieldNumber;
const int CSVCMsg_CreateStringTable::kStringDataFieldNumber;
const int CSVCMsg_CreateStringTable::kUncompressedSizeFieldNumber;
const int CSVCMsg_CreateStringTable::kDataCompressedFieldNumber;
#endif  // !_MSC_VER

CSVCMsg_CreateStringTable::CSVCMsg_CreateStringTable()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:CSVCMsg_CreateStringTable)
}

void CSVCMsg_CreateStringTable::InitAsDefaultInstance() {
}

CSVCMsg_CreateStringTable::CSVCMsg_CreateStringTable(const CSVCMsg_CreateStringTable& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:CSVCMsg_CreateStringTable)
}

void CSVCMsg_CreateStringTable::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  num_entries_ = 0;
  user_data_fixed_size_ = false;
  user_data_size_ = 0;
  user_data_size_bits_ = 0;
  flags_ = 0;
  string_data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  uncompressed_size_ = 0;
  data_compressed_ = false;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CSVCMsg_CreateStringTable::~CSVCMsg_CreateStringTable() {
  // @@protoc_insertion_point(destructor:CSVCMsg_CreateStringTable)
  SharedDtor();
}

void CSVCMsg_CreateStringTable::SharedDtor() {
  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete name_;
  }
  if (string_data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete string_data_;
  }
  if (this != default_instance_) {
  }
}

void CSVCMsg_CreateStringTable::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CSVCMsg_CreateStringTable::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return CSVCMsg_CreateStringTable_descriptor_;
}

const CSVCMsg_CreateStringTable& CSVCMsg_CreateStringTable::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
  return *default_instance_;
}

CSVCMsg_CreateStringTable* CSVCMsg_CreateStringTable::default_instance_ = NULL;

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

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

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

  if (_has_bits_[0 / 32] & 255) {
    ZR_(num_entries_, user_data_fixed_size_);
    if (has_name()) {
      if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        name_->clear();
      }
    }
    if (has_string_data()) {
      if (string_data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        string_data_->clear();
      }
    }
    uncompressed_size_ = 0;
  }
  data_compressed_ = false;

#undef OFFSET_OF_FIELD_
#undef ZR_

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

bool CSVCMsg_CreateStringTable::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:CSVCMsg_CreateStringTable)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional string name = 1;
      case 1: {
        if (tag == 10) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_name()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->name().data(), this->name().length(),
            ::google::protobuf::internal::WireFormat::PARSE,
            "name");
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_num_entries;
        break;
      }

      // optional int32 num_entries = 2;
      case 2: {
        if (tag == 16) {
         parse_num_entries:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &num_entries_)));
          set_has_num_entries();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_user_data_fixed_size;
        break;
      }

      // optional bool user_data_fixed_size = 3;
      case 3: {
        if (tag == 24) {
         parse_user_data_fixed_size:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &user_data_fixed_size_)));
          set_has_user_data_fixed_size();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(32)) goto parse_user_data_size;
        break;
      }

      // optional int32 user_data_size = 4;
      case 4: {
        if (tag == 32) {
         parse_user_data_size:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &user_data_size_)));
          set_has_user_data_size();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(40)) goto parse_user_data_size_bits;
        break;
      }

      // optional int32 user_data_size_bits = 5;
      case 5: {
        if (tag == 40) {
         parse_user_data_size_bits:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &user_data_size_bits_)));
          set_has_user_data_size_bits();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(48)) goto parse_flags;
        break;
      }

      // optional int32 flags = 6;
      case 6: {
        if (tag == 48) {
         parse_flags:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &flags_)));
          set_has_flags();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(58)) goto parse_string_data;
        break;
      }

      // optional bytes string_data = 7;
      case 7: {
        if (tag == 58) {
         parse_string_data:
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_string_data()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(64)) goto parse_uncompressed_size;
        break;
      }

      // optional int32 uncompressed_size = 8;
      case 8: {
        if (tag == 64) {
         parse_uncompressed_size:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &uncompressed_size_)));
          set_has_uncompressed_size();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(72)) goto parse_data_compressed;
        break;
      }

      // optional bool data_compressed = 9;
      case 9: {
        if (tag == 72) {
         parse_data_compressed:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &data_compressed_)));
          set_has_data_compressed();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

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

void CSVCMsg_CreateStringTable::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:CSVCMsg_CreateStringTable)
  // optional string name = 1;
  if (has_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->name().data(), this->name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "name");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->name(), output);
  }

  // optional int32 num_entries = 2;
  if (has_num_entries()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->num_entries(), output);
  }

  // optional bool user_data_fixed_size = 3;
  if (has_user_data_fixed_size()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->user_data_fixed_size(), output);
  }

  // optional int32 user_data_size = 4;
  if (has_user_data_size()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->user_data_size(), output);
  }

  // optional int32 user_data_size_bits = 5;
  if (has_user_data_size_bits()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(5, this->user_data_size_bits(), output);
  }

  // optional int32 flags = 6;
  if (has_flags()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(6, this->flags(), output);
  }

  // optional bytes string_data = 7;
  if (has_string_data()) {
    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
      7, this->string_data(), output);
  }

  // optional int32 uncompressed_size = 8;
  if (has_uncompressed_size()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(8, this->uncompressed_size(), output);
  }

  // optional bool data_compressed = 9;
  if (has_data_compressed()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(9, this->data_compressed(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:CSVCMsg_CreateStringTable)
}

::google::protobuf::uint8* CSVCMsg_CreateStringTable::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:CSVCMsg_CreateStringTable)
  // optional string name = 1;
  if (has_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->name().data(), this->name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "name");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        1, this->name(), target);
  }

  // optional int32 num_entries = 2;
  if (has_num_entries()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->num_entries(), target);
  }

  // optional bool user_data_fixed_size = 3;
  if (has_user_data_fixed_size()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->user_data_fixed_size(), target);
  }

  // optional int32 user_data_size = 4;
  if (has_user_data_size()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(4, this->user_data_size(), target);
  }

  // optional int32 user_data_size_bits = 5;
  if (has_user_data_size_bits()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(5, this->user_data_size_bits(), target);
  }

  // optional int32 flags = 6;
  if (has_flags()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(6, this->flags(), target);
  }

  // optional bytes string_data = 7;
  if (has_string_data()) {
    target =
      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
        7, this->string_data(), target);
  }

  // optional int32 uncompressed_size = 8;
  if (has_uncompressed_size()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(8, this->uncompressed_size(), target);
  }

  // optional bool data_compressed = 9;
  if (has_data_compressed()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(9, this->data_compressed(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:CSVCMsg_CreateStringTable)
  return target;
}

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

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

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

    // optional bool user_data_fixed_size = 3;
    if (has_user_data_fixed_size()) {
      total_size += 1 + 1;
    }

    // optional int32 user_data_size = 4;
    if (has_user_data_size()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->user_data_size());
    }

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

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

    // optional bytes string_data = 7;
    if (has_string_data()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->string_data());
    }

    // optional int32 uncompressed_size = 8;
    if (has_uncompressed_size()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->uncompressed_size());
    }

  }
  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
    // optional bool data_compressed = 9;
    if (has_data_compressed()) {
      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 CSVCMsg_CreateStringTable::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const CSVCMsg_CreateStringTable* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const CSVCMsg_CreateStringTable*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void CSVCMsg_CreateStringTable::MergeFrom(const CSVCMsg_CreateStringTable& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_name()) {
      set_name(from.name());
    }
    if (from.has_num_entries()) {
      set_num_entries(from.num_entries());
    }
    if (from.has_user_data_fixed_size()) {
      set_user_data_fixed_size(from.user_data_fixed_size());
    }
    if (from.has_user_data_size()) {
      set_user_data_size(from.user_data_size());
    }
    if (from.has_user_data_size_bits()) {
      set_user_data_size_bits(from.user_data_size_bits());
    }
    if (from.has_flags()) {
      set_flags(from.flags());
    }
    if (from.has_string_data()) {
      set_string_data(from.string_data());
    }
    if (from.has_uncompressed_size()) {
      set_uncompressed_size(from.uncompressed_size());
    }
  }
  if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
    if (from.has_data_compressed()) {
      set_data_compressed(from.data_compressed());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void CSVCMsg_CreateStringTable::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool CSVCMsg_CreateStringTable::IsInitialized() const {

  return true;
}

void CSVCMsg_CreateStringTable::Swap(CSVCMsg_CreateStringTable* other) {
  if (other != this) {
    std::swap(name_, other->name_);
    std::swap(num_entries_, other->num_entries_);
    std::swap(user_data_fixed_size_, other->user_data_fixed_size_);
    std::swap(user_data_size_, other->user_data_size_);
    std::swap(user_data_size_bits_, other->user_data_size_bits_);
    std::swap(flags_, other->flags_);
    std::swap(string_data_, other->string_data_);
    std::swap(uncompressed_size_, other->uncompressed_size_);
    std::swap(data_compressed_, other->data_compressed_);
    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 CSVCMsg_CreateStringTable::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CSVCMsg_CreateStringTable_descriptor_;
  metadata.reflection = CSVCMsg_CreateStringTable_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int CSVCMsg_UpdateStringTable::kTableIdFieldNumber;
const int CSVCMsg_UpdateStringTable::kNumChangedEntriesFieldNumber;
const int CSVCMsg_UpdateStringTable::kStringDataFieldNumber;
#endif  // !_MSC_VER

CSVCMsg_UpdateStringTable::CSVCMsg_UpdateStringTable()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:CSVCMsg_UpdateStringTable)
}

void CSVCMsg_UpdateStringTable::InitAsDefaultInstance() {
}

CSVCMsg_UpdateStringTable::CSVCMsg_UpdateStringTable(const CSVCMsg_UpdateStringTable& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:CSVCMsg_UpdateStringTable)
}

void CSVCMsg_UpdateStringTable::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  table_id_ = 0;
  num_changed_entries_ = 0;
  string_data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CSVCMsg_UpdateStringTable::~CSVCMsg_UpdateStringTable() {
  // @@protoc_insertion_point(destructor:CSVCMsg_UpdateStringTable)
  SharedDtor();
}

void CSVCMsg_UpdateStringTable::SharedDtor() {
  if (string_data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete string_data_;
  }
  if (this != default_instance_) {
  }
}

void CSVCMsg_UpdateStringTable::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CSVCMsg_UpdateStringTable::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return CSVCMsg_UpdateStringTable_descriptor_;
}

const CSVCMsg_UpdateStringTable& CSVCMsg_UpdateStringTable::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
  return *default_instance_;
}

CSVCMsg_UpdateStringTable* CSVCMsg_UpdateStringTable::default_instance_ = NULL;

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

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

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

  if (_has_bits_[0 / 32] & 7) {
    ZR_(table_id_, num_changed_entries_);
    if (has_string_data()) {
      if (string_data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        string_data_->clear();
      }
    }
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

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

bool CSVCMsg_UpdateStringTable::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:CSVCMsg_UpdateStringTable)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 table_id = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &table_id_)));
          set_has_table_id();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_num_changed_entries;
        break;
      }

      // optional int32 num_changed_entries = 2;
      case 2: {
        if (tag == 16) {
         parse_num_changed_entries:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &num_changed_entries_)));
          set_has_num_changed_entries();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_string_data;
        break;
      }

      // optional bytes string_data = 3;
      case 3: {
        if (tag == 26) {
         parse_string_data:
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_string_data()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

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

void CSVCMsg_UpdateStringTable::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:CSVCMsg_UpdateStringTable)
  // optional int32 table_id = 1;
  if (has_table_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->table_id(), output);
  }

  // optional int32 num_changed_entries = 2;
  if (has_num_changed_entries()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->num_changed_entries(), output);
  }

  // optional bytes string_data = 3;
  if (has_string_data()) {
    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
      3, this->string_data(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:CSVCMsg_UpdateStringTable)
}

::google::protobuf::uint8* CSVCMsg_UpdateStringTable::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:CSVCMsg_UpdateStringTable)
  // optional int32 table_id = 1;
  if (has_table_id()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->table_id(), target);
  }

  // optional int32 num_changed_entries = 2;
  if (has_num_changed_entries()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->num_changed_entries(), target);
  }

  // optional bytes string_data = 3;
  if (has_string_data()) {
    target =
      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
        3, this->string_data(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:CSVCMsg_UpdateStringTable)
  return target;
}

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional int32 table_id = 1;
    if (has_table_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->table_id());
    }

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

    // optional bytes string_data = 3;
    if (has_string_data()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->string_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 CSVCMsg_UpdateStringTable::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const CSVCMsg_UpdateStringTable* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const CSVCMsg_UpdateStringTable*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void CSVCMsg_UpdateStringTable::MergeFrom(const CSVCMsg_UpdateStringTable& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_table_id()) {
      set_table_id(from.table_id());
    }
    if (from.has_num_changed_entries()) {
      set_num_changed_entries(from.num_changed_entries());
    }
    if (from.has_string_data()) {
      set_string_data(from.string_data());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void CSVCMsg_UpdateStringTable::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool CSVCMsg_UpdateStringTable::IsInitialized() const {

  return true;
}

void CSVCMsg_UpdateStringTable::Swap(CSVCMsg_UpdateStringTable* other) {
  if (other != this) {
    std::swap(table_id_, other->table_id_);
    std::swap(num_changed_entries_, other->num_changed_entries_);
    std::swap(string_data_, other->string_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 CSVCMsg_UpdateStringTable::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CSVCMsg_UpdateStringTable_descriptor_;
  metadata.reflection = CSVCMsg_UpdateStringTable_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int CSVCMsg_VoiceData::kAudioFieldNumber;
const int CSVCMsg_VoiceData::kClientFieldNumber;
const int CSVCMsg_VoiceData::kProximityFieldNumber;
const int CSVCMsg_VoiceData::kXuidFieldNumber;
const int CSVCMsg_VoiceData::kAudibleMaskFieldNumber;
const int CSVCMsg_VoiceData::kTickFieldNumber;
#endif  // !_MSC_VER

CSVCMsg_VoiceData::CSVCMsg_VoiceData()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:CSVCMsg_VoiceData)
}

void CSVCMsg_VoiceData::InitAsDefaultInstance() {
  audio_ = const_cast< ::CMsgVoiceAudio*>(&::CMsgVoiceAudio::default_instance());
}

CSVCMsg_VoiceData::CSVCMsg_VoiceData(const CSVCMsg_VoiceData& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:CSVCMsg_VoiceData)
}

void CSVCMsg_VoiceData::SharedCtor() {
  _cached_size_ = 0;
  audio_ = NULL;
  client_ = 0;
  proximity_ = false;
  xuid_ = GOOGLE_ULONGLONG(0);
  audible_mask_ = 0;
  tick_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CSVCMsg_VoiceData::~CSVCMsg_VoiceData() {
  // @@protoc_insertion_point(destructor:CSVCMsg_VoiceData)
  SharedDtor();
}

void CSVCMsg_VoiceData::SharedDtor() {
  if (this != default_instance_) {
    delete audio_;
  }
}

void CSVCMsg_VoiceData::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CSVCMsg_VoiceData::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return CSVCMsg_VoiceData_descriptor_;
}

const CSVCMsg_VoiceData& CSVCMsg_VoiceData::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
  return *default_instance_;
}

CSVCMsg_VoiceData* CSVCMsg_VoiceData::default_instance_ = NULL;

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

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

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

  if (_has_bits_[0 / 32] & 63) {
    ZR_(client_, tick_);
    if (has_audio()) {
      if (audio_ != NULL) audio_->::CMsgVoiceAudio::Clear();
    }
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

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

bool CSVCMsg_VoiceData::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:CSVCMsg_VoiceData)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .CMsgVoiceAudio audio = 1;
      case 1: {
        if (tag == 10) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_audio()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_client;
        break;
      }

      // optional int32 client = 2;
      case 2: {
        if (tag == 16) {
         parse_client:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &client_)));
          set_has_client();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_proximity;
        break;
      }

      // optional bool proximity = 3;
      case 3: {
        if (tag == 24) {
         parse_proximity:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &proximity_)));
          set_has_proximity();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(33)) goto parse_xuid;
        break;
      }

      // optional fixed64 xuid = 4;
      case 4: {
        if (tag == 33) {
         parse_xuid:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                 input, &xuid_)));
          set_has_xuid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(40)) goto parse_audible_mask;
        break;
      }

      // optional int32 audible_mask = 5;
      case 5: {
        if (tag == 40) {
         parse_audible_mask:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &audible_mask_)));
          set_has_audible_mask();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(48)) goto parse_tick;
        break;
      }

      // optional uint32 tick = 6;
      case 6: {
        if (tag == 48) {
         parse_tick:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &tick_)));
          set_has_tick();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

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

void CSVCMsg_VoiceData::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:CSVCMsg_VoiceData)
  // optional .CMsgVoiceAudio audio = 1;
  if (has_audio()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->audio(), output);
  }

  // optional int32 client = 2;
  if (has_client()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->client(), output);
  }

  // optional bool proximity = 3;
  if (has_proximity()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->proximity(), output);
  }

  // optional fixed64 xuid = 4;
  if (has_xuid()) {
    ::google::protobuf::internal::WireFormatLite::WriteFixed64(4, this->xuid(), output);
  }

  // optional int32 audible_mask = 5;
  if (has_audible_mask()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(5, this->audible_mask(), output);
  }

  // optional uint32 tick = 6;
  if (has_tick()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(6, this->tick(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:CSVCMsg_VoiceData)
}

::google::protobuf::uint8* CSVCMsg_VoiceData::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:CSVCMsg_VoiceData)
  // optional .CMsgVoiceAudio audio = 1;
  if (has_audio()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->audio(), target);
  }

  // optional int32 client = 2;
  if (has_client()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->client(), target);
  }

  // optional bool proximity = 3;
  if (has_proximity()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->proximity(), target);
  }

  // optional fixed64 xuid = 4;
  if (has_xuid()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(4, this->xuid(), target);
  }

  // optional int32 audible_mask = 5;
  if (has_audible_mask()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(5, this->audible_mask(), target);
  }

  // optional uint32 tick = 6;
  if (has_tick()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(6, this->tick(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:CSVCMsg_VoiceData)
  return target;
}

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional .CMsgVoiceAudio audio = 1;
    if (has_audio()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->audio());
    }

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

    // optional bool proximity = 3;
    if (has_proximity()) {
      total_size += 1 + 1;
    }

    // optional fixed64 xuid = 4;
    if (has_xuid()) {
      total_size += 1 + 8;
    }

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

    // optional uint32 tick = 6;
    if (has_tick()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->tick());
    }

  }
  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 CSVCMsg_VoiceData::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const CSVCMsg_VoiceData* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const CSVCMsg_VoiceData*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void CSVCMsg_VoiceData::MergeFrom(const CSVCMsg_VoiceData& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_audio()) {
      mutable_audio()->::CMsgVoiceAudio::MergeFrom(from.audio());
    }
    if (from.has_client()) {
      set_client(from.client());
    }
    if (from.has_proximity()) {
      set_proximity(from.proximity());
    }
    if (from.has_xuid()) {
      set_xuid(from.xuid());
    }
    if (from.has_audible_mask()) {
      set_audible_mask(from.audible_mask());
    }
    if (from.has_tick()) {
      set_tick(from.tick());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void CSVCMsg_VoiceData::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool CSVCMsg_VoiceData::IsInitialized() const {

  return true;
}

void CSVCMsg_VoiceData::Swap(CSVCMsg_VoiceData* other) {
  if (other != this) {
    std::swap(audio_, other->audio_);
    std::swap(client_, other->client_);
    std::swap(proximity_, other->proximity_);
    std::swap(xuid_, other->xuid_);
    std::swap(audible_mask_, other->audible_mask_);
    std::swap(tick_, other->tick_);
    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 CSVCMsg_VoiceData::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CSVCMsg_VoiceData_descriptor_;
  metadata.reflection = CSVCMsg_VoiceData_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int CSVCMsg_PacketReliable::kTickFieldNumber;
const int CSVCMsg_PacketReliable::kMessagessizeFieldNumber;
const int CSVCMsg_PacketReliable::kStateFieldNumber;
#endif  // !_MSC_VER

CSVCMsg_PacketReliable::CSVCMsg_PacketReliable()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:CSVCMsg_PacketReliable)
}

void CSVCMsg_PacketReliable::InitAsDefaultInstance() {
}

CSVCMsg_PacketReliable::CSVCMsg_PacketReliable(const CSVCMsg_PacketReliable& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:CSVCMsg_PacketReliable)
}

void CSVCMsg_PacketReliable::SharedCtor() {
  _cached_size_ = 0;
  tick_ = 0;
  messagessize_ = 0;
  state_ = false;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CSVCMsg_PacketReliable::~CSVCMsg_PacketReliable() {
  // @@protoc_insertion_point(destructor:CSVCMsg_PacketReliable)
  SharedDtor();
}

void CSVCMsg_PacketReliable::SharedDtor() {
  if (this != default_instance_) {
  }
}

void CSVCMsg_PacketReliable::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CSVCMsg_PacketReliable::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return CSVCMsg_PacketReliable_descriptor_;
}

const CSVCMsg_PacketReliable& CSVCMsg_PacketReliable::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
  return *default_instance_;
}

CSVCMsg_PacketReliable* CSVCMsg_PacketReliable::default_instance_ = NULL;

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

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

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

  ZR_(tick_, state_);

#undef OFFSET_OF_FIELD_
#undef ZR_

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

bool CSVCMsg_PacketReliable::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:CSVCMsg_PacketReliable)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 tick = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &tick_)));
          set_has_tick();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_messagessize;
        break;
      }

      // optional int32 messagessize = 2;
      case 2: {
        if (tag == 16) {
         parse_messagessize:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &messagessize_)));
          set_has_messagessize();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_state;
        break;
      }

      // optional bool state = 3;
      case 3: {
        if (tag == 24) {
         parse_state:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &state_)));
          set_has_state();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

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

void CSVCMsg_PacketReliable::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:CSVCMsg_PacketReliable)
  // optional int32 tick = 1;
  if (has_tick()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->tick(), output);
  }

  // optional int32 messagessize = 2;
  if (has_messagessize()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->messagessize(), output);
  }

  // optional bool state = 3;
  if (has_state()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->state(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:CSVCMsg_PacketReliable)
}

::google::protobuf::uint8* CSVCMsg_PacketReliable::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:CSVCMsg_PacketReliable)
  // optional int32 tick = 1;
  if (has_tick()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->tick(), target);
  }

  // optional int32 messagessize = 2;
  if (has_messagessize()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->messagessize(), target);
  }

  // optional bool state = 3;
  if (has_state()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->state(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:CSVCMsg_PacketReliable)
  return target;
}

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional int32 tick = 1;
    if (has_tick()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->tick());
    }

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

    // optional bool state = 3;
    if (has_state()) {
      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 CSVCMsg_PacketReliable::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const CSVCMsg_PacketReliable* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const CSVCMsg_PacketReliable*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void CSVCMsg_PacketReliable::MergeFrom(const CSVCMsg_PacketReliable& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_tick()) {
      set_tick(from.tick());
    }
    if (from.has_messagessize()) {
      set_messagessize(from.messagessize());
    }
    if (from.has_state()) {
      set_state(from.state());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void CSVCMsg_PacketReliable::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool CSVCMsg_PacketReliable::IsInitialized() const {

  return true;
}

void CSVCMsg_PacketReliable::Swap(CSVCMsg_PacketReliable* other) {
  if (other != this) {
    std::swap(tick_, other->tick_);
    std::swap(messagessize_, other->messagessize_);
    std::swap(state_, other->state_);
    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 CSVCMsg_PacketReliable::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CSVCMsg_PacketReliable_descriptor_;
  metadata.reflection = CSVCMsg_PacketReliable_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int CSVCMsg_FullFrameSplit::kTickFieldNumber;
const int CSVCMsg_FullFrameSplit::kSectionFieldNumber;
const int CSVCMsg_FullFrameSplit::kTotalFieldNumber;
const int CSVCMsg_FullFrameSplit::kDataFieldNumber;
#endif  // !_MSC_VER

CSVCMsg_FullFrameSplit::CSVCMsg_FullFrameSplit()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:CSVCMsg_FullFrameSplit)
}

void CSVCMsg_FullFrameSplit::InitAsDefaultInstance() {
}

CSVCMsg_FullFrameSplit::CSVCMsg_FullFrameSplit(const CSVCMsg_FullFrameSplit& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:CSVCMsg_FullFrameSplit)
}

void CSVCMsg_FullFrameSplit::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  tick_ = 0;
  section_ = 0;
  total_ = 0;
  data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CSVCMsg_FullFrameSplit::~CSVCMsg_FullFrameSplit() {
  // @@protoc_insertion_point(destructor:CSVCMsg_FullFrameSplit)
  SharedDtor();
}

void CSVCMsg_FullFrameSplit::SharedDtor() {
  if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete data_;
  }
  if (this != default_instance_) {
  }
}

void CSVCMsg_FullFrameSplit::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CSVCMsg_FullFrameSplit::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return CSVCMsg_FullFrameSplit_descriptor_;
}

const CSVCMsg_FullFrameSplit& CSVCMsg_FullFrameSplit::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
  return *default_instance_;
}

CSVCMsg_FullFrameSplit* CSVCMsg_FullFrameSplit::default_instance_ = NULL;

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

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

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

  if (_has_bits_[0 / 32] & 15) {
    ZR_(tick_, section_);
    total_ = 0;
    if (has_data()) {
      if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        data_->clear();
      }
    }
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

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

bool CSVCMsg_FullFrameSplit::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:CSVCMsg_FullFrameSplit)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 tick = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &tick_)));
          set_has_tick();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_section;
        break;
      }

      // optional int32 section = 2;
      case 2: {
        if (tag == 16) {
         parse_section:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &section_)));
          set_has_section();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_total;
        break;
      }

      // optional int32 total = 3;
      case 3: {
        if (tag == 24) {
         parse_total:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &total_)));
          set_has_total();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(34)) goto parse_data;
        break;
      }

      // optional bytes data = 4;
      case 4: {
        if (tag == 34) {
         parse_data:
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_data()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

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

void CSVCMsg_FullFrameSplit::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:CSVCMsg_FullFrameSplit)
  // optional int32 tick = 1;
  if (has_tick()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->tick(), output);
  }

  // optional int32 section = 2;
  if (has_section()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->section(), output);
  }

  // optional int32 total = 3;
  if (has_total()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->total(), output);
  }

  // optional bytes data = 4;
  if (has_data()) {
    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
      4, this->data(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:CSVCMsg_FullFrameSplit)
}

::google::protobuf::uint8* CSVCMsg_FullFrameSplit::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:CSVCMsg_FullFrameSplit)
  // optional int32 tick = 1;
  if (has_tick()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->tick(), target);
  }

  // optional int32 section = 2;
  if (has_section()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->section(), target);
  }

  // optional int32 total = 3;
  if (has_total()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->total(), target);
  }

  // optional bytes data = 4;
  if (has_data()) {
    target =
      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
        4, this->data(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:CSVCMsg_FullFrameSplit)
  return target;
}

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional int32 tick = 1;
    if (has_tick()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->tick());
    }

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

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

    // optional bytes data = 4;
    if (has_data()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->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 CSVCMsg_FullFrameSplit::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const CSVCMsg_FullFrameSplit* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const CSVCMsg_FullFrameSplit*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void CSVCMsg_FullFrameSplit::MergeFrom(const CSVCMsg_FullFrameSplit& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_tick()) {
      set_tick(from.tick());
    }
    if (from.has_section()) {
      set_section(from.section());
    }
    if (from.has_total()) {
      set_total(from.total());
    }
    if (from.has_data()) {
      set_data(from.data());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void CSVCMsg_FullFrameSplit::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool CSVCMsg_FullFrameSplit::IsInitialized() const {

  return true;
}

void CSVCMsg_FullFrameSplit::Swap(CSVCMsg_FullFrameSplit* other) {
  if (other != this) {
    std::swap(tick_, other->tick_);
    std::swap(section_, other->section_);
    std::swap(total_, other->total_);
    std::swap(data_, other->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 CSVCMsg_FullFrameSplit::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CSVCMsg_FullFrameSplit_descriptor_;
  metadata.reflection = CSVCMsg_FullFrameSplit_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int CSVCMsg_CmdKeyValues::kDataFieldNumber;
#endif  // !_MSC_VER

CSVCMsg_CmdKeyValues::CSVCMsg_CmdKeyValues()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:CSVCMsg_CmdKeyValues)
}

void CSVCMsg_CmdKeyValues::InitAsDefaultInstance() {
}

CSVCMsg_CmdKeyValues::CSVCMsg_CmdKeyValues(const CSVCMsg_CmdKeyValues& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:CSVCMsg_CmdKeyValues)
}

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

CSVCMsg_CmdKeyValues::~CSVCMsg_CmdKeyValues() {
  // @@protoc_insertion_point(destructor:CSVCMsg_CmdKeyValues)
  SharedDtor();
}

void CSVCMsg_CmdKeyValues::SharedDtor() {
  if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete data_;
  }
  if (this != default_instance_) {
  }
}

void CSVCMsg_CmdKeyValues::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CSVCMsg_CmdKeyValues::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return CSVCMsg_CmdKeyValues_descriptor_;
}

const CSVCMsg_CmdKeyValues& CSVCMsg_CmdKeyValues::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
  return *default_instance_;
}

CSVCMsg_CmdKeyValues* CSVCMsg_CmdKeyValues::default_instance_ = NULL;

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

void CSVCMsg_CmdKeyValues::Clear() {
  if (has_data()) {
    if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
      data_->clear();
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool CSVCMsg_CmdKeyValues::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:CSVCMsg_CmdKeyValues)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional bytes data = 1;
      case 1: {
        if (tag == 10) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_data()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

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

void CSVCMsg_CmdKeyValues::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:CSVCMsg_CmdKeyValues)
  // optional bytes data = 1;
  if (has_data()) {
    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
      1, this->data(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:CSVCMsg_CmdKeyValues)
}

::google::protobuf::uint8* CSVCMsg_CmdKeyValues::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:CSVCMsg_CmdKeyValues)
  // optional bytes data = 1;
  if (has_data()) {
    target =
      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
        1, this->data(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:CSVCMsg_CmdKeyValues)
  return target;
}

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional bytes data = 1;
    if (has_data()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->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 CSVCMsg_CmdKeyValues::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const CSVCMsg_CmdKeyValues* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const CSVCMsg_CmdKeyValues*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void CSVCMsg_CmdKeyValues::MergeFrom(const CSVCMsg_CmdKeyValues& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_data()) {
      set_data(from.data());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void CSVCMsg_CmdKeyValues::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool CSVCMsg_CmdKeyValues::IsInitialized() const {

  return true;
}

void CSVCMsg_CmdKeyValues::Swap(CSVCMsg_CmdKeyValues* other) {
  if (other != this) {
    std::swap(data_, other->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 CSVCMsg_CmdKeyValues::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CSVCMsg_CmdKeyValues_descriptor_;
  metadata.reflection = CSVCMsg_CmdKeyValues_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int CMsgIPCAddress::kComputerGuidFieldNumber;
const int CMsgIPCAddress::kProcessIdFieldNumber;
#endif  // !_MSC_VER

CMsgIPCAddress::CMsgIPCAddress()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:CMsgIPCAddress)
}

void CMsgIPCAddress::InitAsDefaultInstance() {
}

CMsgIPCAddress::CMsgIPCAddress(const CMsgIPCAddress& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:CMsgIPCAddress)
}

void CMsgIPCAddress::SharedCtor() {
  _cached_size_ = 0;
  computer_guid_ = GOOGLE_ULONGLONG(0);
  process_id_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CMsgIPCAddress::~CMsgIPCAddress() {
  // @@protoc_insertion_point(destructor:CMsgIPCAddress)
  SharedDtor();
}

void CMsgIPCAddress::SharedDtor() {
  if (this != default_instance_) {
  }
}

void CMsgIPCAddress::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CMsgIPCAddress::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return CMsgIPCAddress_descriptor_;
}

const CMsgIPCAddress& CMsgIPCAddress::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
  return *default_instance_;
}

CMsgIPCAddress* CMsgIPCAddress::default_instance_ = NULL;

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

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

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

  ZR_(computer_guid_, process_id_);

#undef OFFSET_OF_FIELD_
#undef ZR_

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

bool CMsgIPCAddress::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:CMsgIPCAddress)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional fixed64 computer_guid = 1;
      case 1: {
        if (tag == 9) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                 input, &computer_guid_)));
          set_has_computer_guid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_process_id;
        break;
      }

      // optional uint32 process_id = 2;
      case 2: {
        if (tag == 16) {
         parse_process_id:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &process_id_)));
          set_has_process_id();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

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

void CMsgIPCAddress::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:CMsgIPCAddress)
  // optional fixed64 computer_guid = 1;
  if (has_computer_guid()) {
    ::google::protobuf::internal::WireFormatLite::WriteFixed64(1, this->computer_guid(), output);
  }

  // optional uint32 process_id = 2;
  if (has_process_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->process_id(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:CMsgIPCAddress)
}

::google::protobuf::uint8* CMsgIPCAddress::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:CMsgIPCAddress)
  // optional fixed64 computer_guid = 1;
  if (has_computer_guid()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(1, this->computer_guid(), target);
  }

  // optional uint32 process_id = 2;
  if (has_process_id()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->process_id(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:CMsgIPCAddress)
  return target;
}

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional fixed64 computer_guid = 1;
    if (has_computer_guid()) {
      total_size += 1 + 8;
    }

    // optional uint32 process_id = 2;
    if (has_process_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->process_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 CMsgIPCAddress::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const CMsgIPCAddress* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const CMsgIPCAddress*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void CMsgIPCAddress::MergeFrom(const CMsgIPCAddress& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_computer_guid()) {
      set_computer_guid(from.computer_guid());
    }
    if (from.has_process_id()) {
      set_process_id(from.process_id());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void CMsgIPCAddress::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool CMsgIPCAddress::IsInitialized() const {

  return true;
}

void CMsgIPCAddress::Swap(CMsgIPCAddress* other) {
  if (other != this) {
    std::swap(computer_guid_, other->computer_guid_);
    std::swap(process_id_, other->process_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 CMsgIPCAddress::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CMsgIPCAddress_descriptor_;
  metadata.reflection = CMsgIPCAddress_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int CMsgServerPeer::kPlayerSlotFieldNumber;
const int CMsgServerPeer::kSteamidFieldNumber;
const int CMsgServerPeer::kIpcFieldNumber;
const int CMsgServerPeer::kTheyHearYouFieldNumber;
const int CMsgServerPeer::kYouHearThemFieldNumber;
const int CMsgServerPeer::kIsListenserverHostFieldNumber;
#endif  // !_MSC_VER

CMsgServerPeer::CMsgServerPeer()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:CMsgServerPeer)
}

void CMsgServerPeer::InitAsDefaultInstance() {
  ipc_ = const_cast< ::CMsgIPCAddress*>(&::CMsgIPCAddress::default_instance());
}

CMsgServerPeer::CMsgServerPeer(const CMsgServerPeer& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:CMsgServerPeer)
}

void CMsgServerPeer::SharedCtor() {
  _cached_size_ = 0;
  player_slot_ = 0;
  steamid_ = GOOGLE_ULONGLONG(0);
  ipc_ = NULL;
  they_hear_you_ = false;
  you_hear_them_ = false;
  is_listenserver_host_ = false;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CMsgServerPeer::~CMsgServerPeer() {
  // @@protoc_insertion_point(destructor:CMsgServerPeer)
  SharedDtor();
}

void CMsgServerPeer::SharedDtor() {
  if (this != default_instance_) {
    delete ipc_;
  }
}

void CMsgServerPeer::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CMsgServerPeer::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return CMsgServerPeer_descriptor_;
}

const CMsgServerPeer& CMsgServerPeer::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
  return *default_instance_;
}

CMsgServerPeer* CMsgServerPeer::default_instance_ = NULL;

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

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

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

  if (_has_bits_[0 / 32] & 63) {
    ZR_(player_slot_, is_listenserver_host_);
    steamid_ = GOOGLE_ULONGLONG(0);
    if (has_ipc()) {
      if (ipc_ != NULL) ipc_->::CMsgIPCAddress::Clear();
    }
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

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

bool CMsgServerPeer::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:CMsgServerPeer)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 player_slot = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &player_slot_)));
          set_has_player_slot();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(17)) goto parse_steamid;
        break;
      }

      // optional fixed64 steamid = 2;
      case 2: {
        if (tag == 17) {
         parse_steamid:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
                 input, &steamid_)));
          set_has_steamid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_ipc;
        break;
      }

      // optional .CMsgIPCAddress ipc = 3;
      case 3: {
        if (tag == 26) {
         parse_ipc:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_ipc()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(32)) goto parse_they_hear_you;
        break;
      }

      // optional bool they_hear_you = 4;
      case 4: {
        if (tag == 32) {
         parse_they_hear_you:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &they_hear_you_)));
          set_has_they_hear_you();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(40)) goto parse_you_hear_them;
        break;
      }

      // optional bool you_hear_them = 5;
      case 5: {
        if (tag == 40) {
         parse_you_hear_them:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &you_hear_them_)));
          set_has_you_hear_them();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(48)) goto parse_is_listenserver_host;
        break;
      }

      // optional bool is_listenserver_host = 6;
      case 6: {
        if (tag == 48) {
         parse_is_listenserver_host:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &is_listenserver_host_)));
          set_has_is_listenserver_host();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

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

void CMsgServerPeer::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:CMsgServerPeer)
  // optional int32 player_slot = 1;
  if (has_player_slot()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->player_slot(), output);
  }

  // optional fixed64 steamid = 2;
  if (has_steamid()) {
    ::google::protobuf::internal::WireFormatLite::WriteFixed64(2, this->steamid(), output);
  }

  // optional .CMsgIPCAddress ipc = 3;
  if (has_ipc()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      3, this->ipc(), output);
  }

  // optional bool they_hear_you = 4;
  if (has_they_hear_you()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->they_hear_you(), output);
  }

  // optional bool you_hear_them = 5;
  if (has_you_hear_them()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(5, this->you_hear_them(), output);
  }

  // optional bool is_listenserver_host = 6;
  if (has_is_listenserver_host()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(6, this->is_listenserver_host(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:CMsgServerPeer)
}

::google::protobuf::uint8* CMsgServerPeer::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:CMsgServerPeer)
  // optional int32 player_slot = 1;
  if (has_player_slot()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->player_slot(), target);
  }

  // optional fixed64 steamid = 2;
  if (has_steamid()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(2, this->steamid(), target);
  }

  // optional .CMsgIPCAddress ipc = 3;
  if (has_ipc()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        3, this->ipc(), target);
  }

  // optional bool they_hear_you = 4;
  if (has_they_hear_you()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(4, this->they_hear_you(), target);
  }

  // optional bool you_hear_them = 5;
  if (has_you_hear_them()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(5, this->you_hear_them(), target);
  }

  // optional bool is_listenserver_host = 6;
  if (has_is_listenserver_host()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(6, this->is_listenserver_host(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:CMsgServerPeer)
  return target;
}

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional int32 player_slot = 1;
    if (has_player_slot()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->player_slot());
    }

    // optional fixed64 steamid = 2;
    if (has_steamid()) {
      total_size += 1 + 8;
    }

    // optional .CMsgIPCAddress ipc = 3;
    if (has_ipc()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->ipc());
    }

    // optional bool they_hear_you = 4;
    if (has_they_hear_you()) {
      total_size += 1 + 1;
    }

    // optional bool you_hear_them = 5;
    if (has_you_hear_them()) {
      total_size += 1 + 1;
    }

    // optional bool is_listenserver_host = 6;
    if (has_is_listenserver_host()) {
      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 CMsgServerPeer::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const CMsgServerPeer* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const CMsgServerPeer*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void CMsgServerPeer::MergeFrom(const CMsgServerPeer& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_player_slot()) {
      set_player_slot(from.player_slot());
    }
    if (from.has_steamid()) {
      set_steamid(from.steamid());
    }
    if (from.has_ipc()) {
      mutable_ipc()->::CMsgIPCAddress::MergeFrom(from.ipc());
    }
    if (from.has_they_hear_you()) {
      set_they_hear_you(from.they_hear_you());
    }
    if (from.has_you_hear_them()) {
      set_you_hear_them(from.you_hear_them());
    }
    if (from.has_is_listenserver_host()) {
      set_is_listenserver_host(from.is_listenserver_host());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void CMsgServerPeer::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool CMsgServerPeer::IsInitialized() const {

  return true;
}

void CMsgServerPeer::Swap(CMsgServerPeer* other) {
  if (other != this) {
    std::swap(player_slot_, other->player_slot_);
    std::swap(steamid_, other->steamid_);
    std::swap(ipc_, other->ipc_);
    std::swap(they_hear_you_, other->they_hear_you_);
    std::swap(you_hear_them_, other->you_hear_them_);
    std::swap(is_listenserver_host_, other->is_listenserver_host_);
    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 CMsgServerPeer::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CMsgServerPeer_descriptor_;
  metadata.reflection = CMsgServerPeer_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int CSVCMsg_PeerList::kPeerFieldNumber;
#endif  // !_MSC_VER

CSVCMsg_PeerList::CSVCMsg_PeerList()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:CSVCMsg_PeerList)
}

void CSVCMsg_PeerList::InitAsDefaultInstance() {
}

CSVCMsg_PeerList::CSVCMsg_PeerList(const CSVCMsg_PeerList& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:CSVCMsg_PeerList)
}

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

CSVCMsg_PeerList::~CSVCMsg_PeerList() {
  // @@protoc_insertion_point(destructor:CSVCMsg_PeerList)
  SharedDtor();
}

void CSVCMsg_PeerList::SharedDtor() {
  if (this != default_instance_) {
  }
}

void CSVCMsg_PeerList::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CSVCMsg_PeerList::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return CSVCMsg_PeerList_descriptor_;
}

const CSVCMsg_PeerList& CSVCMsg_PeerList::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
  return *default_instance_;
}

CSVCMsg_PeerList* CSVCMsg_PeerList::default_instance_ = NULL;

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

void CSVCMsg_PeerList::Clear() {
  peer_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool CSVCMsg_PeerList::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:CSVCMsg_PeerList)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // repeated .CMsgServerPeer peer = 1;
      case 1: {
        if (tag == 10) {
         parse_peer:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_peer()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(10)) goto parse_peer;
        if (input->ExpectAtEnd()) goto success;
        break;
      }

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

void CSVCMsg_PeerList::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:CSVCMsg_PeerList)
  // repeated .CMsgServerPeer peer = 1;
  for (int i = 0; i < this->peer_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->peer(i), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:CSVCMsg_PeerList)
}

::google::protobuf::uint8* CSVCMsg_PeerList::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:CSVCMsg_PeerList)
  // repeated .CMsgServerPeer peer = 1;
  for (int i = 0; i < this->peer_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->peer(i), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:CSVCMsg_PeerList)
  return target;
}

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

  // repeated .CMsgServerPeer peer = 1;
  total_size += 1 * this->peer_size();
  for (int i = 0; i < this->peer_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->peer(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 CSVCMsg_PeerList::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const CSVCMsg_PeerList* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const CSVCMsg_PeerList*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

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

void CSVCMsg_PeerList::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool CSVCMsg_PeerList::IsInitialized() const {

  return true;
}

void CSVCMsg_PeerList::Swap(CSVCMsg_PeerList* other) {
  if (other != this) {
    peer_.Swap(&other->peer_);
    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 CSVCMsg_PeerList::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CSVCMsg_PeerList_descriptor_;
  metadata.reflection = CSVCMsg_PeerList_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int CSVCMsg_ClearAllStringTables::kMapnameFieldNumber;
const int CSVCMsg_ClearAllStringTables::kMapCrcFieldNumber;
#endif  // !_MSC_VER

CSVCMsg_ClearAllStringTables::CSVCMsg_ClearAllStringTables()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:CSVCMsg_ClearAllStringTables)
}

void CSVCMsg_ClearAllStringTables::InitAsDefaultInstance() {
}

CSVCMsg_ClearAllStringTables::CSVCMsg_ClearAllStringTables(const CSVCMsg_ClearAllStringTables& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:CSVCMsg_ClearAllStringTables)
}

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

CSVCMsg_ClearAllStringTables::~CSVCMsg_ClearAllStringTables() {
  // @@protoc_insertion_point(destructor:CSVCMsg_ClearAllStringTables)
  SharedDtor();
}

void CSVCMsg_ClearAllStringTables::SharedDtor() {
  if (mapname_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete mapname_;
  }
  if (this != default_instance_) {
  }
}

void CSVCMsg_ClearAllStringTables::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CSVCMsg_ClearAllStringTables::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return CSVCMsg_ClearAllStringTables_descriptor_;
}

const CSVCMsg_ClearAllStringTables& CSVCMsg_ClearAllStringTables::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
  return *default_instance_;
}

CSVCMsg_ClearAllStringTables* CSVCMsg_ClearAllStringTables::default_instance_ = NULL;

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

void CSVCMsg_ClearAllStringTables::Clear() {
  if (_has_bits_[0 / 32] & 3) {
    if (has_mapname()) {
      if (mapname_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        mapname_->clear();
      }
    }
    map_crc_ = 0u;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool CSVCMsg_ClearAllStringTables::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:CSVCMsg_ClearAllStringTables)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional string mapname = 1;
      case 1: {
        if (tag == 10) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_mapname()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->mapname().data(), this->mapname().length(),
            ::google::protobuf::internal::WireFormat::PARSE,
            "mapname");
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_map_crc;
        break;
      }

      // optional uint32 map_crc = 2;
      case 2: {
        if (tag == 16) {
         parse_map_crc:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &map_crc_)));
          set_has_map_crc();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

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

void CSVCMsg_ClearAllStringTables::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:CSVCMsg_ClearAllStringTables)
  // optional string mapname = 1;
  if (has_mapname()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->mapname().data(), this->mapname().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "mapname");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->mapname(), output);
  }

  // optional uint32 map_crc = 2;
  if (has_map_crc()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->map_crc(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:CSVCMsg_ClearAllStringTables)
}

::google::protobuf::uint8* CSVCMsg_ClearAllStringTables::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:CSVCMsg_ClearAllStringTables)
  // optional string mapname = 1;
  if (has_mapname()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->mapname().data(), this->mapname().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "mapname");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        1, this->mapname(), target);
  }

  // optional uint32 map_crc = 2;
  if (has_map_crc()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->map_crc(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:CSVCMsg_ClearAllStringTables)
  return target;
}

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

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

    // optional uint32 map_crc = 2;
    if (has_map_crc()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->map_crc());
    }

  }
  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 CSVCMsg_ClearAllStringTables::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const CSVCMsg_ClearAllStringTables* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const CSVCMsg_ClearAllStringTables*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void CSVCMsg_ClearAllStringTables::MergeFrom(const CSVCMsg_ClearAllStringTables& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_mapname()) {
      set_mapname(from.mapname());
    }
    if (from.has_map_crc()) {
      set_map_crc(from.map_crc());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void CSVCMsg_ClearAllStringTables::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool CSVCMsg_ClearAllStringTables::IsInitialized() const {

  return true;
}

void CSVCMsg_ClearAllStringTables::Swap(CSVCMsg_ClearAllStringTables* other) {
  if (other != this) {
    std::swap(mapname_, other->mapname_);
    std::swap(map_crc_, other->map_crc_);
    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 CSVCMsg_ClearAllStringTables::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CSVCMsg_ClearAllStringTables_descriptor_;
  metadata.reflection = CSVCMsg_ClearAllStringTables_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int ProtoFlattenedSerializerField_t::kVarTypeSymFieldNumber;
const int ProtoFlattenedSerializerField_t::kVarNameSymFieldNumber;
const int ProtoFlattenedSerializerField_t::kBitCountFieldNumber;
const int ProtoFlattenedSerializerField_t::kLowValueFieldNumber;
const int ProtoFlattenedSerializerField_t::kHighValueFieldNumber;
const int ProtoFlattenedSerializerField_t::kEncodeFlagsFieldNumber;
const int ProtoFlattenedSerializerField_t::kFieldSerializerNameSymFieldNumber;
const int ProtoFlattenedSerializerField_t::kFieldSerializerVersionFieldNumber;
const int ProtoFlattenedSerializerField_t::kSendNodeSymFieldNumber;
#endif  // !_MSC_VER

ProtoFlattenedSerializerField_t::ProtoFlattenedSerializerField_t()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:ProtoFlattenedSerializerField_t)
}

void ProtoFlattenedSerializerField_t::InitAsDefaultInstance() {
}

ProtoFlattenedSerializerField_t::ProtoFlattenedSerializerField_t(const ProtoFlattenedSerializerField_t& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:ProtoFlattenedSerializerField_t)
}

void ProtoFlattenedSerializerField_t::SharedCtor() {
  _cached_size_ = 0;
  var_type_sym_ = 0;
  var_name_sym_ = 0;
  bit_count_ = 0;
  low_value_ = 0;
  high_value_ = 0;
  encode_flags_ = 0;
  field_serializer_name_sym_ = 0;
  field_serializer_version_ = 0;
  send_node_sym_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

ProtoFlattenedSerializerField_t::~ProtoFlattenedSerializerField_t() {
  // @@protoc_insertion_point(destructor:ProtoFlattenedSerializerField_t)
  SharedDtor();
}

void ProtoFlattenedSerializerField_t::SharedDtor() {
  if (this != default_instance_) {
  }
}

void ProtoFlattenedSerializerField_t::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* ProtoFlattenedSerializerField_t::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return ProtoFlattenedSerializerField_t_descriptor_;
}

const ProtoFlattenedSerializerField_t& ProtoFlattenedSerializerField_t::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
  return *default_instance_;
}

ProtoFlattenedSerializerField_t* ProtoFlattenedSerializerField_t::default_instance_ = NULL;

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

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

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

  if (_has_bits_[0 / 32] & 255) {
    ZR_(var_type_sym_, field_serializer_version_);
  }
  send_node_sym_ = 0;

#undef OFFSET_OF_FIELD_
#undef ZR_

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

bool ProtoFlattenedSerializerField_t::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:ProtoFlattenedSerializerField_t)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 var_type_sym = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &var_type_sym_)));
          set_has_var_type_sym();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_var_name_sym;
        break;
      }

      // optional int32 var_name_sym = 2;
      case 2: {
        if (tag == 16) {
         parse_var_name_sym:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &var_name_sym_)));
          set_has_var_name_sym();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_bit_count;
        break;
      }

      // optional int32 bit_count = 3;
      case 3: {
        if (tag == 24) {
         parse_bit_count:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &bit_count_)));
          set_has_bit_count();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(37)) goto parse_low_value;
        break;
      }

      // optional float low_value = 4;
      case 4: {
        if (tag == 37) {
         parse_low_value:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &low_value_)));
          set_has_low_value();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(45)) goto parse_high_value;
        break;
      }

      // optional float high_value = 5;
      case 5: {
        if (tag == 45) {
         parse_high_value:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &high_value_)));
          set_has_high_value();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(48)) goto parse_encode_flags;
        break;
      }

      // optional int32 encode_flags = 6;
      case 6: {
        if (tag == 48) {
         parse_encode_flags:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &encode_flags_)));
          set_has_encode_flags();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(56)) goto parse_field_serializer_name_sym;
        break;
      }

      // optional int32 field_serializer_name_sym = 7;
      case 7: {
        if (tag == 56) {
         parse_field_serializer_name_sym:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &field_serializer_name_sym_)));
          set_has_field_serializer_name_sym();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(64)) goto parse_field_serializer_version;
        break;
      }

      // optional int32 field_serializer_version = 8;
      case 8: {
        if (tag == 64) {
         parse_field_serializer_version:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &field_serializer_version_)));
          set_has_field_serializer_version();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(72)) goto parse_send_node_sym;
        break;
      }

      // optional int32 send_node_sym = 9;
      case 9: {
        if (tag == 72) {
         parse_send_node_sym:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &send_node_sym_)));
          set_has_send_node_sym();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

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

void ProtoFlattenedSerializerField_t::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:ProtoFlattenedSerializerField_t)
  // optional int32 var_type_sym = 1;
  if (has_var_type_sym()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->var_type_sym(), output);
  }

  // optional int32 var_name_sym = 2;
  if (has_var_name_sym()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->var_name_sym(), output);
  }

  // optional int32 bit_count = 3;
  if (has_bit_count()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->bit_count(), output);
  }

  // optional float low_value = 4;
  if (has_low_value()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(4, this->low_value(), output);
  }

  // optional float high_value = 5;
  if (has_high_value()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(5, this->high_value(), output);
  }

  // optional int32 encode_flags = 6;
  if (has_encode_flags()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(6, this->encode_flags(), output);
  }

  // optional int32 field_serializer_name_sym = 7;
  if (has_field_serializer_name_sym()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(7, this->field_serializer_name_sym(), output);
  }

  // optional int32 field_serializer_version = 8;
  if (has_field_serializer_version()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(8, this->field_serializer_version(), output);
  }

  // optional int32 send_node_sym = 9;
  if (has_send_node_sym()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(9, this->send_node_sym(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:ProtoFlattenedSerializerField_t)
}

::google::protobuf::uint8* ProtoFlattenedSerializerField_t::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:ProtoFlattenedSerializerField_t)
  // optional int32 var_type_sym = 1;
  if (has_var_type_sym()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->var_type_sym(), target);
  }

  // optional int32 var_name_sym = 2;
  if (has_var_name_sym()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->var_name_sym(), target);
  }

  // optional int32 bit_count = 3;
  if (has_bit_count()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->bit_count(), target);
  }

  // optional float low_value = 4;
  if (has_low_value()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(4, this->low_value(), target);
  }

  // optional float high_value = 5;
  if (has_high_value()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(5, this->high_value(), target);
  }

  // optional int32 encode_flags = 6;
  if (has_encode_flags()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(6, this->encode_flags(), target);
  }

  // optional int32 field_serializer_name_sym = 7;
  if (has_field_serializer_name_sym()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(7, this->field_serializer_name_sym(), target);
  }

  // optional int32 field_serializer_version = 8;
  if (has_field_serializer_version()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(8, this->field_serializer_version(), target);
  }

  // optional int32 send_node_sym = 9;
  if (has_send_node_sym()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(9, this->send_node_sym(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:ProtoFlattenedSerializerField_t)
  return target;
}

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional int32 var_type_sym = 1;
    if (has_var_type_sym()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->var_type_sym());
    }

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

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

    // optional float low_value = 4;
    if (has_low_value()) {
      total_size += 1 + 4;
    }

    // optional float high_value = 5;
    if (has_high_value()) {
      total_size += 1 + 4;
    }

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

    // optional int32 field_serializer_name_sym = 7;
    if (has_field_serializer_name_sym()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->field_serializer_name_sym());
    }

    // optional int32 field_serializer_version = 8;
    if (has_field_serializer_version()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->field_serializer_version());
    }

  }
  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
    // optional int32 send_node_sym = 9;
    if (has_send_node_sym()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->send_node_sym());
    }

  }
  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 ProtoFlattenedSerializerField_t::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const ProtoFlattenedSerializerField_t* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const ProtoFlattenedSerializerField_t*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void ProtoFlattenedSerializerField_t::MergeFrom(const ProtoFlattenedSerializerField_t& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_var_type_sym()) {
      set_var_type_sym(from.var_type_sym());
    }
    if (from.has_var_name_sym()) {
      set_var_name_sym(from.var_name_sym());
    }
    if (from.has_bit_count()) {
      set_bit_count(from.bit_count());
    }
    if (from.has_low_value()) {
      set_low_value(from.low_value());
    }
    if (from.has_high_value()) {
      set_high_value(from.high_value());
    }
    if (from.has_encode_flags()) {
      set_encode_flags(from.encode_flags());
    }
    if (from.has_field_serializer_name_sym()) {
      set_field_serializer_name_sym(from.field_serializer_name_sym());
    }
    if (from.has_field_serializer_version()) {
      set_field_serializer_version(from.field_serializer_version());
    }
  }
  if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
    if (from.has_send_node_sym()) {
      set_send_node_sym(from.send_node_sym());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void ProtoFlattenedSerializerField_t::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool ProtoFlattenedSerializerField_t::IsInitialized() const {

  return true;
}

void ProtoFlattenedSerializerField_t::Swap(ProtoFlattenedSerializerField_t* other) {
  if (other != this) {
    std::swap(var_type_sym_, other->var_type_sym_);
    std::swap(var_name_sym_, other->var_name_sym_);
    std::swap(bit_count_, other->bit_count_);
    std::swap(low_value_, other->low_value_);
    std::swap(high_value_, other->high_value_);
    std::swap(encode_flags_, other->encode_flags_);
    std::swap(field_serializer_name_sym_, other->field_serializer_name_sym_);
    std::swap(field_serializer_version_, other->field_serializer_version_);
    std::swap(send_node_sym_, other->send_node_sym_);
    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 ProtoFlattenedSerializerField_t::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = ProtoFlattenedSerializerField_t_descriptor_;
  metadata.reflection = ProtoFlattenedSerializerField_t_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int ProtoFlattenedSerializer_t::kSerializerNameSymFieldNumber;
const int ProtoFlattenedSerializer_t::kSerializerVersionFieldNumber;
const int ProtoFlattenedSerializer_t::kFieldsIndexFieldNumber;
#endif  // !_MSC_VER

ProtoFlattenedSerializer_t::ProtoFlattenedSerializer_t()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:ProtoFlattenedSerializer_t)
}

void ProtoFlattenedSerializer_t::InitAsDefaultInstance() {
}

ProtoFlattenedSerializer_t::ProtoFlattenedSerializer_t(const ProtoFlattenedSerializer_t& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:ProtoFlattenedSerializer_t)
}

void ProtoFlattenedSerializer_t::SharedCtor() {
  _cached_size_ = 0;
  serializer_name_sym_ = 0;
  serializer_version_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

ProtoFlattenedSerializer_t::~ProtoFlattenedSerializer_t() {
  // @@protoc_insertion_point(destructor:ProtoFlattenedSerializer_t)
  SharedDtor();
}

void ProtoFlattenedSerializer_t::SharedDtor() {
  if (this != default_instance_) {
  }
}

void ProtoFlattenedSerializer_t::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* ProtoFlattenedSerializer_t::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return ProtoFlattenedSerializer_t_descriptor_;
}

const ProtoFlattenedSerializer_t& ProtoFlattenedSerializer_t::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
  return *default_instance_;
}

ProtoFlattenedSerializer_t* ProtoFlattenedSerializer_t::default_instance_ = NULL;

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

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

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

  ZR_(serializer_name_sym_, serializer_version_);

#undef OFFSET_OF_FIELD_
#undef ZR_

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

bool ProtoFlattenedSerializer_t::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:ProtoFlattenedSerializer_t)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 serializer_name_sym = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &serializer_name_sym_)));
          set_has_serializer_name_sym();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_serializer_version;
        break;
      }

      // optional int32 serializer_version = 2;
      case 2: {
        if (tag == 16) {
         parse_serializer_version:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &serializer_version_)));
          set_has_serializer_version();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_fields_index;
        break;
      }

      // repeated int32 fields_index = 3;
      case 3: {
        if (tag == 24) {
         parse_fields_index:
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 1, 24, input, this->mutable_fields_index())));
        } else if (tag == 26) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, this->mutable_fields_index())));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_fields_index;
        if (input->ExpectAtEnd()) goto success;
        break;
      }

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

void ProtoFlattenedSerializer_t::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:ProtoFlattenedSerializer_t)
  // optional int32 serializer_name_sym = 1;
  if (has_serializer_name_sym()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->serializer_name_sym(), output);
  }

  // optional int32 serializer_version = 2;
  if (has_serializer_version()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->serializer_version(), output);
  }

  // repeated int32 fields_index = 3;
  for (int i = 0; i < this->fields_index_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(
      3, this->fields_index(i), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:ProtoFlattenedSerializer_t)
}

::google::protobuf::uint8* ProtoFlattenedSerializer_t::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:ProtoFlattenedSerializer_t)
  // optional int32 serializer_name_sym = 1;
  if (has_serializer_name_sym()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->serializer_name_sym(), target);
  }

  // optional int32 serializer_version = 2;
  if (has_serializer_version()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->serializer_version(), target);
  }

  // repeated int32 fields_index = 3;
  for (int i = 0; i < this->fields_index_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteInt32ToArray(3, this->fields_index(i), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:ProtoFlattenedSerializer_t)
  return target;
}

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional int32 serializer_name_sym = 1;
    if (has_serializer_name_sym()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->serializer_name_sym());
    }

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

  }
  // repeated int32 fields_index = 3;
  {
    int data_size = 0;
    for (int i = 0; i < this->fields_index_size(); i++) {
      data_size += ::google::protobuf::internal::WireFormatLite::
        Int32Size(this->fields_index(i));
    }
    total_size += 1 * this->fields_index_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 ProtoFlattenedSerializer_t::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const ProtoFlattenedSerializer_t* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const ProtoFlattenedSerializer_t*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void ProtoFlattenedSerializer_t::MergeFrom(const ProtoFlattenedSerializer_t& from) {
  GOOGLE_CHECK_NE(&from, this);
  fields_index_.MergeFrom(from.fields_index_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_serializer_name_sym()) {
      set_serializer_name_sym(from.serializer_name_sym());
    }
    if (from.has_serializer_version()) {
      set_serializer_version(from.serializer_version());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void ProtoFlattenedSerializer_t::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool ProtoFlattenedSerializer_t::IsInitialized() const {

  return true;
}

void ProtoFlattenedSerializer_t::Swap(ProtoFlattenedSerializer_t* other) {
  if (other != this) {
    std::swap(serializer_name_sym_, other->serializer_name_sym_);
    std::swap(serializer_version_, other->serializer_version_);
    fields_index_.Swap(&other->fields_index_);
    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 ProtoFlattenedSerializer_t::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = ProtoFlattenedSerializer_t_descriptor_;
  metadata.reflection = ProtoFlattenedSerializer_t_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int CSVCMsg_FlattenedSerializer::kSerializersFieldNumber;
const int CSVCMsg_FlattenedSerializer::kSymbolsFieldNumber;
const int CSVCMsg_FlattenedSerializer::kFieldsFieldNumber;
#endif  // !_MSC_VER

CSVCMsg_FlattenedSerializer::CSVCMsg_FlattenedSerializer()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:CSVCMsg_FlattenedSerializer)
}

void CSVCMsg_FlattenedSerializer::InitAsDefaultInstance() {
}

CSVCMsg_FlattenedSerializer::CSVCMsg_FlattenedSerializer(const CSVCMsg_FlattenedSerializer& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:CSVCMsg_FlattenedSerializer)
}

void CSVCMsg_FlattenedSerializer::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CSVCMsg_FlattenedSerializer::~CSVCMsg_FlattenedSerializer() {
  // @@protoc_insertion_point(destructor:CSVCMsg_FlattenedSerializer)
  SharedDtor();
}

void CSVCMsg_FlattenedSerializer::SharedDtor() {
  if (this != default_instance_) {
  }
}

void CSVCMsg_FlattenedSerializer::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CSVCMsg_FlattenedSerializer::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return CSVCMsg_FlattenedSerializer_descriptor_;
}

const CSVCMsg_FlattenedSerializer& CSVCMsg_FlattenedSerializer::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
  return *default_instance_;
}

CSVCMsg_FlattenedSerializer* CSVCMsg_FlattenedSerializer::default_instance_ = NULL;

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

void CSVCMsg_FlattenedSerializer::Clear() {
  serializers_.Clear();
  symbols_.Clear();
  fields_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool CSVCMsg_FlattenedSerializer::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:CSVCMsg_FlattenedSerializer)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // repeated .ProtoFlattenedSerializer_t serializers = 1;
      case 1: {
        if (tag == 10) {
         parse_serializers:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_serializers()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(10)) goto parse_serializers;
        if (input->ExpectTag(18)) goto parse_symbols;
        break;
      }

      // repeated string symbols = 2;
      case 2: {
        if (tag == 18) {
         parse_symbols:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->add_symbols()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->symbols(this->symbols_size() - 1).data(),
            this->symbols(this->symbols_size() - 1).length(),
            ::google::protobuf::internal::WireFormat::PARSE,
            "symbols");
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_symbols;
        if (input->ExpectTag(26)) goto parse_fields;
        break;
      }

      // repeated .ProtoFlattenedSerializerField_t fields = 3;
      case 3: {
        if (tag == 26) {
         parse_fields:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_fields()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_fields;
        if (input->ExpectAtEnd()) goto success;
        break;
      }

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

void CSVCMsg_FlattenedSerializer::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:CSVCMsg_FlattenedSerializer)
  // repeated .ProtoFlattenedSerializer_t serializers = 1;
  for (int i = 0; i < this->serializers_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->serializers(i), output);
  }

  // repeated string symbols = 2;
  for (int i = 0; i < this->symbols_size(); i++) {
  ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
    this->symbols(i).data(), this->symbols(i).length(),
    ::google::protobuf::internal::WireFormat::SERIALIZE,
    "symbols");
    ::google::protobuf::internal::WireFormatLite::WriteString(
      2, this->symbols(i), output);
  }

  // repeated .ProtoFlattenedSerializerField_t fields = 3;
  for (int i = 0; i < this->fields_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      3, this->fields(i), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:CSVCMsg_FlattenedSerializer)
}

::google::protobuf::uint8* CSVCMsg_FlattenedSerializer::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:CSVCMsg_FlattenedSerializer)
  // repeated .ProtoFlattenedSerializer_t serializers = 1;
  for (int i = 0; i < this->serializers_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->serializers(i), target);
  }

  // repeated string symbols = 2;
  for (int i = 0; i < this->symbols_size(); i++) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->symbols(i).data(), this->symbols(i).length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "symbols");
    target = ::google::protobuf::internal::WireFormatLite::
      WriteStringToArray(2, this->symbols(i), target);
  }

  // repeated .ProtoFlattenedSerializerField_t fields = 3;
  for (int i = 0; i < this->fields_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        3, this->fields(i), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:CSVCMsg_FlattenedSerializer)
  return target;
}

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

  // repeated .ProtoFlattenedSerializer_t serializers = 1;
  total_size += 1 * this->serializers_size();
  for (int i = 0; i < this->serializers_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->serializers(i));
  }

  // repeated string symbols = 2;
  total_size += 1 * this->symbols_size();
  for (int i = 0; i < this->symbols_size(); i++) {
    total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
      this->symbols(i));
  }

  // repeated .ProtoFlattenedSerializerField_t fields = 3;
  total_size += 1 * this->fields_size();
  for (int i = 0; i < this->fields_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->fields(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 CSVCMsg_FlattenedSerializer::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const CSVCMsg_FlattenedSerializer* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const CSVCMsg_FlattenedSerializer*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void CSVCMsg_FlattenedSerializer::MergeFrom(const CSVCMsg_FlattenedSerializer& from) {
  GOOGLE_CHECK_NE(&from, this);
  serializers_.MergeFrom(from.serializers_);
  symbols_.MergeFrom(from.symbols_);
  fields_.MergeFrom(from.fields_);
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void CSVCMsg_FlattenedSerializer::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool CSVCMsg_FlattenedSerializer::IsInitialized() const {

  return true;
}

void CSVCMsg_FlattenedSerializer::Swap(CSVCMsg_FlattenedSerializer* other) {
  if (other != this) {
    serializers_.Swap(&other->serializers_);
    symbols_.Swap(&other->symbols_);
    fields_.Swap(&other->fields_);
    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 CSVCMsg_FlattenedSerializer::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CSVCMsg_FlattenedSerializer_descriptor_;
  metadata.reflection = CSVCMsg_FlattenedSerializer_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int CSVCMsg_StopSound::kGuidFieldNumber;
#endif  // !_MSC_VER

CSVCMsg_StopSound::CSVCMsg_StopSound()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:CSVCMsg_StopSound)
}

void CSVCMsg_StopSound::InitAsDefaultInstance() {
}

CSVCMsg_StopSound::CSVCMsg_StopSound(const CSVCMsg_StopSound& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:CSVCMsg_StopSound)
}

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

CSVCMsg_StopSound::~CSVCMsg_StopSound() {
  // @@protoc_insertion_point(destructor:CSVCMsg_StopSound)
  SharedDtor();
}

void CSVCMsg_StopSound::SharedDtor() {
  if (this != default_instance_) {
  }
}

void CSVCMsg_StopSound::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CSVCMsg_StopSound::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return CSVCMsg_StopSound_descriptor_;
}

const CSVCMsg_StopSound& CSVCMsg_StopSound::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
  return *default_instance_;
}

CSVCMsg_StopSound* CSVCMsg_StopSound::default_instance_ = NULL;

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

void CSVCMsg_StopSound::Clear() {
  guid_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool CSVCMsg_StopSound::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:CSVCMsg_StopSound)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional fixed32 guid = 1;
      case 1: {
        if (tag == 13) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
                 input, &guid_)));
          set_has_guid();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

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

void CSVCMsg_StopSound::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:CSVCMsg_StopSound)
  // optional fixed32 guid = 1;
  if (has_guid()) {
    ::google::protobuf::internal::WireFormatLite::WriteFixed32(1, this->guid(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:CSVCMsg_StopSound)
}

::google::protobuf::uint8* CSVCMsg_StopSound::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:CSVCMsg_StopSound)
  // optional fixed32 guid = 1;
  if (has_guid()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(1, this->guid(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:CSVCMsg_StopSound)
  return target;
}

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional fixed32 guid = 1;
    if (has_guid()) {
      total_size += 1 + 4;
    }

  }
  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 CSVCMsg_StopSound::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const CSVCMsg_StopSound* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const CSVCMsg_StopSound*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void CSVCMsg_StopSound::MergeFrom(const CSVCMsg_StopSound& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_guid()) {
      set_guid(from.guid());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void CSVCMsg_StopSound::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool CSVCMsg_StopSound::IsInitialized() const {

  return true;
}

void CSVCMsg_StopSound::Swap(CSVCMsg_StopSound* other) {
  if (other != this) {
    std::swap(guid_, other->guid_);
    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 CSVCMsg_StopSound::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CSVCMsg_StopSound_descriptor_;
  metadata.reflection = CSVCMsg_StopSound_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int CBidirMsg_RebroadcastGameEvent::kPosttoserverFieldNumber;
const int CBidirMsg_RebroadcastGameEvent::kBuftypeFieldNumber;
const int CBidirMsg_RebroadcastGameEvent::kClientbitcountFieldNumber;
const int CBidirMsg_RebroadcastGameEvent::kReceivingclientsFieldNumber;
#endif  // !_MSC_VER

CBidirMsg_RebroadcastGameEvent::CBidirMsg_RebroadcastGameEvent()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:CBidirMsg_RebroadcastGameEvent)
}

void CBidirMsg_RebroadcastGameEvent::InitAsDefaultInstance() {
}

CBidirMsg_RebroadcastGameEvent::CBidirMsg_RebroadcastGameEvent(const CBidirMsg_RebroadcastGameEvent& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:CBidirMsg_RebroadcastGameEvent)
}

void CBidirMsg_RebroadcastGameEvent::SharedCtor() {
  _cached_size_ = 0;
  posttoserver_ = false;
  buftype_ = 0;
  clientbitcount_ = 0u;
  receivingclients_ = GOOGLE_ULONGLONG(0);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CBidirMsg_RebroadcastGameEvent::~CBidirMsg_RebroadcastGameEvent() {
  // @@protoc_insertion_point(destructor:CBidirMsg_RebroadcastGameEvent)
  SharedDtor();
}

void CBidirMsg_RebroadcastGameEvent::SharedDtor() {
  if (this != default_instance_) {
  }
}

void CBidirMsg_RebroadcastGameEvent::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CBidirMsg_RebroadcastGameEvent::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return CBidirMsg_RebroadcastGameEvent_descriptor_;
}

const CBidirMsg_RebroadcastGameEvent& CBidirMsg_RebroadcastGameEvent::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
  return *default_instance_;
}

CBidirMsg_RebroadcastGameEvent* CBidirMsg_RebroadcastGameEvent::default_instance_ = NULL;

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

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

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

  ZR_(posttoserver_, clientbitcount_);

#undef OFFSET_OF_FIELD_
#undef ZR_

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

bool CBidirMsg_RebroadcastGameEvent::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:CBidirMsg_RebroadcastGameEvent)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional bool posttoserver = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &posttoserver_)));
          set_has_posttoserver();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_buftype;
        break;
      }

      // optional int32 buftype = 2;
      case 2: {
        if (tag == 16) {
         parse_buftype:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &buftype_)));
          set_has_buftype();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_clientbitcount;
        break;
      }

      // optional uint32 clientbitcount = 3;
      case 3: {
        if (tag == 24) {
         parse_clientbitcount:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &clientbitcount_)));
          set_has_clientbitcount();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(32)) goto parse_receivingclients;
        break;
      }

      // optional uint64 receivingclients = 4;
      case 4: {
        if (tag == 32) {
         parse_receivingclients:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
                 input, &receivingclients_)));
          set_has_receivingclients();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

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

void CBidirMsg_RebroadcastGameEvent::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:CBidirMsg_RebroadcastGameEvent)
  // optional bool posttoserver = 1;
  if (has_posttoserver()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->posttoserver(), output);
  }

  // optional int32 buftype = 2;
  if (has_buftype()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->buftype(), output);
  }

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

  // optional uint64 receivingclients = 4;
  if (has_receivingclients()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt64(4, this->receivingclients(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:CBidirMsg_RebroadcastGameEvent)
}

::google::protobuf::uint8* CBidirMsg_RebroadcastGameEvent::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:CBidirMsg_RebroadcastGameEvent)
  // optional bool posttoserver = 1;
  if (has_posttoserver()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(1, this->posttoserver(), target);
  }

  // optional int32 buftype = 2;
  if (has_buftype()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->buftype(), target);
  }

  // optional uint32 clientbitcount = 3;
  if (has_clientbitcount()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->clientbitcount(), target);
  }

  // optional uint64 receivingclients = 4;
  if (has_receivingclients()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(4, this->receivingclients(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:CBidirMsg_RebroadcastGameEvent)
  return target;
}

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional bool posttoserver = 1;
    if (has_posttoserver()) {
      total_size += 1 + 1;
    }

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

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

    // optional uint64 receivingclients = 4;
    if (has_receivingclients()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt64Size(
          this->receivingclients());
    }

  }
  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 CBidirMsg_RebroadcastGameEvent::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const CBidirMsg_RebroadcastGameEvent* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const CBidirMsg_RebroadcastGameEvent*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void CBidirMsg_RebroadcastGameEvent::MergeFrom(const CBidirMsg_RebroadcastGameEvent& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_posttoserver()) {
      set_posttoserver(from.posttoserver());
    }
    if (from.has_buftype()) {
      set_buftype(from.buftype());
    }
    if (from.has_clientbitcount()) {
      set_clientbitcount(from.clientbitcount());
    }
    if (from.has_receivingclients()) {
      set_receivingclients(from.receivingclients());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void CBidirMsg_RebroadcastGameEvent::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool CBidirMsg_RebroadcastGameEvent::IsInitialized() const {

  return true;
}

void CBidirMsg_RebroadcastGameEvent::Swap(CBidirMsg_RebroadcastGameEvent* other) {
  if (other != this) {
    std::swap(posttoserver_, other->posttoserver_);
    std::swap(buftype_, other->buftype_);
    std::swap(clientbitcount_, other->clientbitcount_);
    std::swap(receivingclients_, other->receivingclients_);
    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 CBidirMsg_RebroadcastGameEvent::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CBidirMsg_RebroadcastGameEvent_descriptor_;
  metadata.reflection = CBidirMsg_RebroadcastGameEvent_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int CBidirMsg_RebroadcastSource::kEventsourceFieldNumber;
#endif  // !_MSC_VER

CBidirMsg_RebroadcastSource::CBidirMsg_RebroadcastSource()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:CBidirMsg_RebroadcastSource)
}

void CBidirMsg_RebroadcastSource::InitAsDefaultInstance() {
}

CBidirMsg_RebroadcastSource::CBidirMsg_RebroadcastSource(const CBidirMsg_RebroadcastSource& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:CBidirMsg_RebroadcastSource)
}

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

CBidirMsg_RebroadcastSource::~CBidirMsg_RebroadcastSource() {
  // @@protoc_insertion_point(destructor:CBidirMsg_RebroadcastSource)
  SharedDtor();
}

void CBidirMsg_RebroadcastSource::SharedDtor() {
  if (this != default_instance_) {
  }
}

void CBidirMsg_RebroadcastSource::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CBidirMsg_RebroadcastSource::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return CBidirMsg_RebroadcastSource_descriptor_;
}

const CBidirMsg_RebroadcastSource& CBidirMsg_RebroadcastSource::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
  return *default_instance_;
}

CBidirMsg_RebroadcastSource* CBidirMsg_RebroadcastSource::default_instance_ = NULL;

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

void CBidirMsg_RebroadcastSource::Clear() {
  eventsource_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool CBidirMsg_RebroadcastSource::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:CBidirMsg_RebroadcastSource)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 eventsource = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &eventsource_)));
          set_has_eventsource();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

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

void CBidirMsg_RebroadcastSource::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:CBidirMsg_RebroadcastSource)
  // optional int32 eventsource = 1;
  if (has_eventsource()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->eventsource(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:CBidirMsg_RebroadcastSource)
}

::google::protobuf::uint8* CBidirMsg_RebroadcastSource::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:CBidirMsg_RebroadcastSource)
  // optional int32 eventsource = 1;
  if (has_eventsource()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->eventsource(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:CBidirMsg_RebroadcastSource)
  return target;
}

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional int32 eventsource = 1;
    if (has_eventsource()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->eventsource());
    }

  }
  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 CBidirMsg_RebroadcastSource::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const CBidirMsg_RebroadcastSource* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const CBidirMsg_RebroadcastSource*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void CBidirMsg_RebroadcastSource::MergeFrom(const CBidirMsg_RebroadcastSource& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_eventsource()) {
      set_eventsource(from.eventsource());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void CBidirMsg_RebroadcastSource::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

bool CBidirMsg_RebroadcastSource::IsInitialized() const {

  return true;
}

void CBidirMsg_RebroadcastSource::Swap(CBidirMsg_RebroadcastSource* other) {
  if (other != this) {
    std::swap(eventsource_, other->eventsource_);
    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 CBidirMsg_RebroadcastSource::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CBidirMsg_RebroadcastSource_descriptor_;
  metadata.reflection = CBidirMsg_RebroadcastSource_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int SerializedNetAddress_t::kSerializedAddressFieldNumber;
#endif  // !_MSC_VER

SerializedNetAddress_t::SerializedNetAddress_t()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SerializedNetAddress_t)
}

void SerializedNetAddress_t::InitAsDefaultInstance() {
}

SerializedNetAddress_t::SerializedNetAddress_t(const SerializedNetAddress_t& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:SerializedNetAddress_t)
}

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

SerializedNetAddress_t::~SerializedNetAddress_t() {
  // @@protoc_insertion_point(destructor:SerializedNetAddress_t)
  SharedDtor();
}

void SerializedNetAddress_t::SharedDtor() {
  if (serializedaddress_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete serializedaddress_;
  }
  if (this != default_instance_) {
  }
}

void SerializedNetAddress_t::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* SerializedNetAddress_t::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return SerializedNetAddress_t_descriptor_;
}

const SerializedNetAddress_t& SerializedNetAddress_t::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
  return *default_instance_;
}

SerializedNetAddress_t* SerializedNetAddress_t::default_instance_ = NULL;

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

void SerializedNetAddress_t::Clear() {
  if (has_serializedaddress()) {
    if (serializedaddress_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
      serializedaddress_->clear();
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool SerializedNetAddress_t::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:SerializedNetAddress_t)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required bytes serializedAddress = 1;
      case 1: {
        if (tag == 10) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_serializedaddress()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

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

void SerializedNetAddress_t::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:SerializedNetAddress_t)
  // required bytes serializedAddress = 1;
  if (has_serializedaddress()) {
    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
      1, this->serializedaddress(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:SerializedNetAddress_t)
}

::google::protobuf::uint8* SerializedNetAddress_t::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:SerializedNetAddress_t)
  // required bytes serializedAddress = 1;
  if (has_serializedaddress()) {
    target =
      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
        1, this->serializedaddress(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SerializedNetAddress_t)
  return target;
}

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required bytes serializedAddress = 1;
    if (has_serializedaddress()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->serializedaddress());
    }

  }
  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 SerializedNetAddress_t::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const SerializedNetAddress_t* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const SerializedNetAddress_t*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void SerializedNetAddress_t::MergeFrom(const SerializedNetAddress_t& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_serializedaddress()) {
      set_serializedaddress(from.serializedaddress());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void SerializedNetAddress_t::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

  return true;
}

void SerializedNetAddress_t::Swap(SerializedNetAddress_t* other) {
  if (other != this) {
    std::swap(serializedaddress_, other->serializedaddress_);
    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 SerializedNetAddress_t::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = SerializedNetAddress_t_descriptor_;
  metadata.reflection = SerializedNetAddress_t_reflection_;
  return metadata;
}


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

const ::google::protobuf::EnumDescriptor* CBidirMsg_RelayInfo_Operation_t_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return CBidirMsg_RelayInfo_Operation_t_descriptor_;
}
bool CBidirMsg_RelayInfo_Operation_t_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
      return true;
    default:
      return false;
  }
}

#ifndef _MSC_VER
const CBidirMsg_RelayInfo_Operation_t CBidirMsg_RelayInfo::RIO_REQUEST_RELAY;
const CBidirMsg_RelayInfo_Operation_t CBidirMsg_RelayInfo::RIO_WILL_RELAY;
const CBidirMsg_RelayInfo_Operation_t CBidirMsg_RelayInfo::RIO_NO_ROUTE;
const CBidirMsg_RelayInfo_Operation_t CBidirMsg_RelayInfo::RIO_REJECT_RELAY;
const CBidirMsg_RelayInfo_Operation_t CBidirMsg_RelayInfo::RIO_ESTABLISH_CONNECTION;
const CBidirMsg_RelayInfo_Operation_t CBidirMsg_RelayInfo::Operation_t_MIN;
const CBidirMsg_RelayInfo_Operation_t CBidirMsg_RelayInfo::Operation_t_MAX;
const int CBidirMsg_RelayInfo::Operation_t_ARRAYSIZE;
#endif  // _MSC_VER
#ifndef _MSC_VER
const int CBidirMsg_RelayInfo::kOperationFieldNumber;
const int CBidirMsg_RelayInfo::kSerializedTargetAddressFieldNumber;
const int CBidirMsg_RelayInfo::kAdditionalHopsFieldNumber;
#endif  // !_MSC_VER

CBidirMsg_RelayInfo::CBidirMsg_RelayInfo()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:CBidirMsg_RelayInfo)
}

void CBidirMsg_RelayInfo::InitAsDefaultInstance() {
  serializedtargetaddress_ = const_cast< ::SerializedNetAddress_t*>(&::SerializedNetAddress_t::default_instance());
}

CBidirMsg_RelayInfo::CBidirMsg_RelayInfo(const CBidirMsg_RelayInfo& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:CBidirMsg_RelayInfo)
}

void CBidirMsg_RelayInfo::SharedCtor() {
  _cached_size_ = 0;
  operation_ = 0;
  serializedtargetaddress_ = NULL;
  additionalhops_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CBidirMsg_RelayInfo::~CBidirMsg_RelayInfo() {
  // @@protoc_insertion_point(destructor:CBidirMsg_RelayInfo)
  SharedDtor();
}

void CBidirMsg_RelayInfo::SharedDtor() {
  if (this != default_instance_) {
    delete serializedtargetaddress_;
  }
}

void CBidirMsg_RelayInfo::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CBidirMsg_RelayInfo::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return CBidirMsg_RelayInfo_descriptor_;
}

const CBidirMsg_RelayInfo& CBidirMsg_RelayInfo::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
  return *default_instance_;
}

CBidirMsg_RelayInfo* CBidirMsg_RelayInfo::default_instance_ = NULL;

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

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

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

  if (_has_bits_[0 / 32] & 7) {
    ZR_(operation_, additionalhops_);
    if (has_serializedtargetaddress()) {
      if (serializedtargetaddress_ != NULL) serializedtargetaddress_->::SerializedNetAddress_t::Clear();
    }
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

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

bool CBidirMsg_RelayInfo::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:CBidirMsg_RelayInfo)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required .CBidirMsg_RelayInfo.Operation_t operation = 1 [default = RIO_REQUEST_RELAY];
      case 1: {
        if (tag == 8) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::CBidirMsg_RelayInfo_Operation_t_IsValid(value)) {
            set_operation(static_cast< ::CBidirMsg_RelayInfo_Operation_t >(value));
          } else {
            mutable_unknown_fields()->AddVarint(1, value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_serializedTargetAddress;
        break;
      }

      // optional .SerializedNetAddress_t serializedTargetAddress = 2;
      case 2: {
        if (tag == 18) {
         parse_serializedTargetAddress:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_serializedtargetaddress()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_additionalHops;
        break;
      }

      // optional uint32 additionalHops = 3;
      case 3: {
        if (tag == 24) {
         parse_additionalHops:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &additionalhops_)));
          set_has_additionalhops();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

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

void CBidirMsg_RelayInfo::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:CBidirMsg_RelayInfo)
  // required .CBidirMsg_RelayInfo.Operation_t operation = 1 [default = RIO_REQUEST_RELAY];
  if (has_operation()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->operation(), output);
  }

  // optional .SerializedNetAddress_t serializedTargetAddress = 2;
  if (has_serializedtargetaddress()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      2, this->serializedtargetaddress(), output);
  }

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

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:CBidirMsg_RelayInfo)
}

::google::protobuf::uint8* CBidirMsg_RelayInfo::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:CBidirMsg_RelayInfo)
  // required .CBidirMsg_RelayInfo.Operation_t operation = 1 [default = RIO_REQUEST_RELAY];
  if (has_operation()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->operation(), target);
  }

  // optional .SerializedNetAddress_t serializedTargetAddress = 2;
  if (has_serializedtargetaddress()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        2, this->serializedtargetaddress(), target);
  }

  // optional uint32 additionalHops = 3;
  if (has_additionalhops()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->additionalhops(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:CBidirMsg_RelayInfo)
  return target;
}

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required .CBidirMsg_RelayInfo.Operation_t operation = 1 [default = RIO_REQUEST_RELAY];
    if (has_operation()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->operation());
    }

    // optional .SerializedNetAddress_t serializedTargetAddress = 2;
    if (has_serializedtargetaddress()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->serializedtargetaddress());
    }

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

  }
  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 CBidirMsg_RelayInfo::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const CBidirMsg_RelayInfo* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const CBidirMsg_RelayInfo*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void CBidirMsg_RelayInfo::MergeFrom(const CBidirMsg_RelayInfo& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_operation()) {
      set_operation(from.operation());
    }
    if (from.has_serializedtargetaddress()) {
      mutable_serializedtargetaddress()->::SerializedNetAddress_t::MergeFrom(from.serializedtargetaddress());
    }
    if (from.has_additionalhops()) {
      set_additionalhops(from.additionalhops());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void CBidirMsg_RelayInfo::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

  if (has_serializedtargetaddress()) {
    if (!this->serializedtargetaddress().IsInitialized()) return false;
  }
  return true;
}

void CBidirMsg_RelayInfo::Swap(CBidirMsg_RelayInfo* other) {
  if (other != this) {
    std::swap(operation_, other->operation_);
    std::swap(serializedtargetaddress_, other->serializedtargetaddress_);
    std::swap(additionalhops_, other->additionalhops_);
    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 CBidirMsg_RelayInfo::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CBidirMsg_RelayInfo_descriptor_;
  metadata.reflection = CBidirMsg_RelayInfo_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int SignedPayload_t::kPayloadDataFieldNumber;
const int SignedPayload_t::kSignatureFieldNumber;
const int SignedPayload_t::kBPayloadEncryptedFieldNumber;
#endif  // !_MSC_VER

SignedPayload_t::SignedPayload_t()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SignedPayload_t)
}

void SignedPayload_t::InitAsDefaultInstance() {
}

SignedPayload_t::SignedPayload_t(const SignedPayload_t& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:SignedPayload_t)
}

void SignedPayload_t::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  payloaddata_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  signature_ = 0u;
  bpayloadencrypted_ = false;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

SignedPayload_t::~SignedPayload_t() {
  // @@protoc_insertion_point(destructor:SignedPayload_t)
  SharedDtor();
}

void SignedPayload_t::SharedDtor() {
  if (payloaddata_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete payloaddata_;
  }
  if (this != default_instance_) {
  }
}

void SignedPayload_t::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* SignedPayload_t::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return SignedPayload_t_descriptor_;
}

const SignedPayload_t& SignedPayload_t::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
  return *default_instance_;
}

SignedPayload_t* SignedPayload_t::default_instance_ = NULL;

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

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

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

  if (_has_bits_[0 / 32] & 7) {
    ZR_(signature_, bpayloadencrypted_);
    if (has_payloaddata()) {
      if (payloaddata_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        payloaddata_->clear();
      }
    }
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

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

bool SignedPayload_t::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:SignedPayload_t)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required bytes payloadData = 1;
      case 1: {
        if (tag == 10) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_payloaddata()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_signature;
        break;
      }

      // required uint32 signature = 2;
      case 2: {
        if (tag == 16) {
         parse_signature:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &signature_)));
          set_has_signature();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_bPayloadEncrypted;
        break;
      }

      // required bool bPayloadEncrypted = 3;
      case 3: {
        if (tag == 24) {
         parse_bPayloadEncrypted:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &bpayloadencrypted_)));
          set_has_bpayloadencrypted();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

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

void SignedPayload_t::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:SignedPayload_t)
  // required bytes payloadData = 1;
  if (has_payloaddata()) {
    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
      1, this->payloaddata(), output);
  }

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

  // required bool bPayloadEncrypted = 3;
  if (has_bpayloadencrypted()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->bpayloadencrypted(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:SignedPayload_t)
}

::google::protobuf::uint8* SignedPayload_t::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:SignedPayload_t)
  // required bytes payloadData = 1;
  if (has_payloaddata()) {
    target =
      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
        1, this->payloaddata(), target);
  }

  // required uint32 signature = 2;
  if (has_signature()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->signature(), target);
  }

  // required bool bPayloadEncrypted = 3;
  if (has_bpayloadencrypted()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->bpayloadencrypted(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:SignedPayload_t)
  return target;
}

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required bytes payloadData = 1;
    if (has_payloaddata()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->payloaddata());
    }

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

    // required bool bPayloadEncrypted = 3;
    if (has_bpayloadencrypted()) {
      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 SignedPayload_t::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const SignedPayload_t* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const SignedPayload_t*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void SignedPayload_t::MergeFrom(const SignedPayload_t& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_payloaddata()) {
      set_payloaddata(from.payloaddata());
    }
    if (from.has_signature()) {
      set_signature(from.signature());
    }
    if (from.has_bpayloadencrypted()) {
      set_bpayloadencrypted(from.bpayloadencrypted());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void SignedPayload_t::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

  return true;
}

void SignedPayload_t::Swap(SignedPayload_t* other) {
  if (other != this) {
    std::swap(payloaddata_, other->payloaddata_);
    std::swap(signature_, other->signature_);
    std::swap(bpayloadencrypted_, other->bpayloadencrypted_);
    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 SignedPayload_t::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = SignedPayload_t_descriptor_;
  metadata.reflection = SignedPayload_t_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int CBidirMsg_RelayPacket_SignedDestinationAddress_t::kSerializedAddrFieldNumber;
const int CBidirMsg_RelayPacket_SignedDestinationAddress_t::kSignatureFieldNumber;
const int CBidirMsg_RelayPacket_SignedDestinationAddress_t::kEncryptedPayloadKeyFieldNumber;
#endif  // !_MSC_VER

CBidirMsg_RelayPacket_SignedDestinationAddress_t::CBidirMsg_RelayPacket_SignedDestinationAddress_t()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:CBidirMsg_RelayPacket.SignedDestinationAddress_t)
}

void CBidirMsg_RelayPacket_SignedDestinationAddress_t::InitAsDefaultInstance() {
  serializedaddr_ = const_cast< ::SerializedNetAddress_t*>(&::SerializedNetAddress_t::default_instance());
}

CBidirMsg_RelayPacket_SignedDestinationAddress_t::CBidirMsg_RelayPacket_SignedDestinationAddress_t(const CBidirMsg_RelayPacket_SignedDestinationAddress_t& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:CBidirMsg_RelayPacket.SignedDestinationAddress_t)
}

void CBidirMsg_RelayPacket_SignedDestinationAddress_t::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  serializedaddr_ = NULL;
  signature_ = 0u;
  encryptedpayloadkey_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CBidirMsg_RelayPacket_SignedDestinationAddress_t::~CBidirMsg_RelayPacket_SignedDestinationAddress_t() {
  // @@protoc_insertion_point(destructor:CBidirMsg_RelayPacket.SignedDestinationAddress_t)
  SharedDtor();
}

void CBidirMsg_RelayPacket_SignedDestinationAddress_t::SharedDtor() {
  if (encryptedpayloadkey_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete encryptedpayloadkey_;
  }
  if (this != default_instance_) {
    delete serializedaddr_;
  }
}

void CBidirMsg_RelayPacket_SignedDestinationAddress_t::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CBidirMsg_RelayPacket_SignedDestinationAddress_t::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return CBidirMsg_RelayPacket_SignedDestinationAddress_t_descriptor_;
}

const CBidirMsg_RelayPacket_SignedDestinationAddress_t& CBidirMsg_RelayPacket_SignedDestinationAddress_t::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
  return *default_instance_;
}

CBidirMsg_RelayPacket_SignedDestinationAddress_t* CBidirMsg_RelayPacket_SignedDestinationAddress_t::default_instance_ = NULL;

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

void CBidirMsg_RelayPacket_SignedDestinationAddress_t::Clear() {
  if (_has_bits_[0 / 32] & 7) {
    if (has_serializedaddr()) {
      if (serializedaddr_ != NULL) serializedaddr_->::SerializedNetAddress_t::Clear();
    }
    signature_ = 0u;
    if (has_encryptedpayloadkey()) {
      if (encryptedpayloadkey_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        encryptedpayloadkey_->clear();
      }
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool CBidirMsg_RelayPacket_SignedDestinationAddress_t::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:CBidirMsg_RelayPacket.SignedDestinationAddress_t)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required .SerializedNetAddress_t serializedAddr = 1;
      case 1: {
        if (tag == 10) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_serializedaddr()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_signature;
        break;
      }

      // required uint32 signature = 2;
      case 2: {
        if (tag == 16) {
         parse_signature:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &signature_)));
          set_has_signature();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_encryptedPayloadKey;
        break;
      }

      // optional bytes encryptedPayloadKey = 3;
      case 3: {
        if (tag == 26) {
         parse_encryptedPayloadKey:
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_encryptedpayloadkey()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

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

void CBidirMsg_RelayPacket_SignedDestinationAddress_t::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:CBidirMsg_RelayPacket.SignedDestinationAddress_t)
  // required .SerializedNetAddress_t serializedAddr = 1;
  if (has_serializedaddr()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->serializedaddr(), output);
  }

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

  // optional bytes encryptedPayloadKey = 3;
  if (has_encryptedpayloadkey()) {
    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
      3, this->encryptedpayloadkey(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:CBidirMsg_RelayPacket.SignedDestinationAddress_t)
}

::google::protobuf::uint8* CBidirMsg_RelayPacket_SignedDestinationAddress_t::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:CBidirMsg_RelayPacket.SignedDestinationAddress_t)
  // required .SerializedNetAddress_t serializedAddr = 1;
  if (has_serializedaddr()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->serializedaddr(), target);
  }

  // required uint32 signature = 2;
  if (has_signature()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->signature(), target);
  }

  // optional bytes encryptedPayloadKey = 3;
  if (has_encryptedpayloadkey()) {
    target =
      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
        3, this->encryptedpayloadkey(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:CBidirMsg_RelayPacket.SignedDestinationAddress_t)
  return target;
}

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required .SerializedNetAddress_t serializedAddr = 1;
    if (has_serializedaddr()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->serializedaddr());
    }

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

    // optional bytes encryptedPayloadKey = 3;
    if (has_encryptedpayloadkey()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->encryptedpayloadkey());
    }

  }
  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 CBidirMsg_RelayPacket_SignedDestinationAddress_t::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const CBidirMsg_RelayPacket_SignedDestinationAddress_t* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const CBidirMsg_RelayPacket_SignedDestinationAddress_t*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void CBidirMsg_RelayPacket_SignedDestinationAddress_t::MergeFrom(const CBidirMsg_RelayPacket_SignedDestinationAddress_t& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_serializedaddr()) {
      mutable_serializedaddr()->::SerializedNetAddress_t::MergeFrom(from.serializedaddr());
    }
    if (from.has_signature()) {
      set_signature(from.signature());
    }
    if (from.has_encryptedpayloadkey()) {
      set_encryptedpayloadkey(from.encryptedpayloadkey());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void CBidirMsg_RelayPacket_SignedDestinationAddress_t::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

  if (has_serializedaddr()) {
    if (!this->serializedaddr().IsInitialized()) return false;
  }
  return true;
}

void CBidirMsg_RelayPacket_SignedDestinationAddress_t::Swap(CBidirMsg_RelayPacket_SignedDestinationAddress_t* other) {
  if (other != this) {
    std::swap(serializedaddr_, other->serializedaddr_);
    std::swap(signature_, other->signature_);
    std::swap(encryptedpayloadkey_, other->encryptedpayloadkey_);
    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 CBidirMsg_RelayPacket_SignedDestinationAddress_t::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CBidirMsg_RelayPacket_SignedDestinationAddress_t_descriptor_;
  metadata.reflection = CBidirMsg_RelayPacket_SignedDestinationAddress_t_reflection_;
  return metadata;
}


// -------------------------------------------------------------------

#ifndef _MSC_VER
const int CBidirMsg_RelayPacket::kPrevhopcountFieldNumber;
const int CBidirMsg_RelayPacket::kOriginalSenderFieldNumber;
const int CBidirMsg_RelayPacket::kSignedPayloadFieldNumber;
const int CBidirMsg_RelayPacket::kRecipientListFieldNumber;
#endif  // !_MSC_VER

CBidirMsg_RelayPacket::CBidirMsg_RelayPacket()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:CBidirMsg_RelayPacket)
}

void CBidirMsg_RelayPacket::InitAsDefaultInstance() {
  originalsender_ = const_cast< ::SerializedNetAddress_t*>(&::SerializedNetAddress_t::default_instance());
  signedpayload_ = const_cast< ::SignedPayload_t*>(&::SignedPayload_t::default_instance());
}

CBidirMsg_RelayPacket::CBidirMsg_RelayPacket(const CBidirMsg_RelayPacket& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:CBidirMsg_RelayPacket)
}

void CBidirMsg_RelayPacket::SharedCtor() {
  _cached_size_ = 0;
  prevhopcount_ = 0u;
  originalsender_ = NULL;
  signedpayload_ = NULL;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CBidirMsg_RelayPacket::~CBidirMsg_RelayPacket() {
  // @@protoc_insertion_point(destructor:CBidirMsg_RelayPacket)
  SharedDtor();
}

void CBidirMsg_RelayPacket::SharedDtor() {
  if (this != default_instance_) {
    delete originalsender_;
    delete signedpayload_;
  }
}

void CBidirMsg_RelayPacket::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CBidirMsg_RelayPacket::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return CBidirMsg_RelayPacket_descriptor_;
}

const CBidirMsg_RelayPacket& CBidirMsg_RelayPacket::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_netmessages_2eproto();
  return *default_instance_;
}

CBidirMsg_RelayPacket* CBidirMsg_RelayPacket::default_instance_ = NULL;

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

void CBidirMsg_RelayPacket::Clear() {
  if (_has_bits_[0 / 32] & 7) {
    prevhopcount_ = 0u;
    if (has_originalsender()) {
      if (originalsender_ != NULL) originalsender_->::SerializedNetAddress_t::Clear();
    }
    if (has_signedpayload()) {
      if (signedpayload_ != NULL) signedpayload_->::SignedPayload_t::Clear();
    }
  }
  recipientlist_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool CBidirMsg_RelayPacket::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:CBidirMsg_RelayPacket)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 prevhopcount = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &prevhopcount_)));
          set_has_prevhopcount();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_originalSender;
        break;
      }

      // required .SerializedNetAddress_t originalSender = 2;
      case 2: {
        if (tag == 18) {
         parse_originalSender:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_originalsender()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_signedPayload;
        break;
      }

      // required .SignedPayload_t signedPayload = 3;
      case 3: {
        if (tag == 26) {
         parse_signedPayload:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_signedpayload()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(34)) goto parse_recipientList;
        break;
      }

      // repeated .CBidirMsg_RelayPacket.SignedDestinationAddress_t recipientList = 4;
      case 4: {
        if (tag == 34) {
         parse_recipientList:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_recipientlist()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(34)) goto parse_recipientList;
        if (input->ExpectAtEnd()) goto success;
        break;
      }

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

void CBidirMsg_RelayPacket::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:CBidirMsg_RelayPacket)
  // required uint32 prevhopcount = 1;
  if (has_prevhopcount()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->prevhopcount(), output);
  }

  // required .SerializedNetAddress_t originalSender = 2;
  if (has_originalsender()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      2, this->originalsender(), output);
  }

  // required .SignedPayload_t signedPayload = 3;
  if (has_signedpayload()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      3, this->signedpayload(), output);
  }

  // repeated .CBidirMsg_RelayPacket.SignedDestinationAddress_t recipientList = 4;
  for (int i = 0; i < this->recipientlist_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      4, this->recipientlist(i), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:CBidirMsg_RelayPacket)
}

::google::protobuf::uint8* CBidirMsg_RelayPacket::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:CBidirMsg_RelayPacket)
  // required uint32 prevhopcount = 1;
  if (has_prevhopcount()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->prevhopcount(), target);
  }

  // required .SerializedNetAddress_t originalSender = 2;
  if (has_originalsender()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        2, this->originalsender(), target);
  }

  // required .SignedPayload_t signedPayload = 3;
  if (has_signedpayload()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        3, this->signedpayload(), target);
  }

  // repeated .CBidirMsg_RelayPacket.SignedDestinationAddress_t recipientList = 4;
  for (int i = 0; i < this->recipientlist_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        4, this->recipientlist(i), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:CBidirMsg_RelayPacket)
  return target;
}

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

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

    // required .SerializedNetAddress_t originalSender = 2;
    if (has_originalsender()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->originalsender());
    }

    // required .SignedPayload_t signedPayload = 3;
    if (has_signedpayload()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->signedpayload());
    }

  }
  // repeated .CBidirMsg_RelayPacket.SignedDestinationAddress_t recipientList = 4;
  total_size += 1 * this->recipientlist_size();
  for (int i = 0; i < this->recipientlist_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->recipientlist(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 CBidirMsg_RelayPacket::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const CBidirMsg_RelayPacket* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const CBidirMsg_RelayPacket*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void CBidirMsg_RelayPacket::MergeFrom(const CBidirMsg_RelayPacket& from) {
  GOOGLE_CHECK_NE(&from, this);
  recipientlist_.MergeFrom(from.recipientlist_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_prevhopcount()) {
      set_prevhopcount(from.prevhopcount());
    }
    if (from.has_originalsender()) {
      mutable_originalsender()->::SerializedNetAddress_t::MergeFrom(from.originalsender());
    }
    if (from.has_signedpayload()) {
      mutable_signedpayload()->::SignedPayload_t::MergeFrom(from.signedpayload());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void CBidirMsg_RelayPacket::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

  if (has_originalsender()) {
    if (!this->originalsender().IsInitialized()) return false;
  }
  if (has_signedpayload()) {
    if (!this->signedpayload().IsInitialized()) return false;
  }
  if (!::google::protobuf::internal::AllAreInitialized(this->recipientlist())) return false;
  return true;
}

void CBidirMsg_RelayPacket::Swap(CBidirMsg_RelayPacket* other) {
  if (other != this) {
    std::swap(prevhopcount_, other->prevhopcount_);
    std::swap(originalsender_, other->originalsender_);
    std::swap(signedpayload_, other->signedpayload_);
    recipientlist_.Swap(&other->recipientlist_);
    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 CBidirMsg_RelayPacket::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CBidirMsg_RelayPacket_descriptor_;
  metadata.reflection = CBidirMsg_RelayPacket_reflection_;
  return metadata;
}


// @@protoc_insertion_point(namespace_scope)

// @@protoc_insertion_point(global_scope)