csgo/cstrike15_src/game/server/generated_proto/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* CMsgVector_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CMsgVector_reflection_ = NULL;
const ::google::protobuf::Descriptor* CMsgVector2D_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CMsgVector2D_reflection_ = NULL;
const ::google::protobuf::Descriptor* CMsgQAngle_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CMsgQAngle_reflection_ = NULL;
const ::google::protobuf::Descriptor* CMsgRGBA_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CMsgRGBA_reflection_ = NULL;
const ::google::protobuf::Descriptor* CNETMsg_Tick_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CNETMsg_Tick_reflection_ = NULL;
const ::google::protobuf::Descriptor* CNETMsg_StringCmd_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CNETMsg_StringCmd_reflection_ = NULL;
const ::google::protobuf::Descriptor* CNETMsg_SignonState_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CNETMsg_SignonState_reflection_ = NULL;
const ::google::protobuf::Descriptor* CMsg_CVars_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CMsg_CVars_reflection_ = NULL;
const ::google::protobuf::Descriptor* CMsg_CVars_CVar_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CMsg_CVars_CVar_reflection_ = NULL;
const ::google::protobuf::Descriptor* CNETMsg_SetConVar_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CNETMsg_SetConVar_reflection_ = NULL;
const ::google::protobuf::Descriptor* CNETMsg_NOP_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CNETMsg_NOP_reflection_ = NULL;
const ::google::protobuf::Descriptor* CNETMsg_Disconnect_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CNETMsg_Disconnect_reflection_ = NULL;
const ::google::protobuf::Descriptor* CNETMsg_File_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CNETMsg_File_reflection_ = NULL;
const ::google::protobuf::Descriptor* CNETMsg_SplitScreenUser_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CNETMsg_SplitScreenUser_reflection_ = NULL;
const ::google::protobuf::Descriptor* CNETMsg_PlayerAvatarData_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CNETMsg_PlayerAvatarData_reflection_ = NULL;
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* 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_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_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_Print_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CSVCMsg_Print_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_SetPause_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CSVCMsg_SetPause_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_SetView_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CSVCMsg_SetView_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_VoiceInit_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CSVCMsg_VoiceInit_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_VoiceData_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CSVCMsg_VoiceData_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_Prefetch_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CSVCMsg_Prefetch_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_UserMessage_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CSVCMsg_UserMessage_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_PaintmapData_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CSVCMsg_PaintmapData_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_GameEvent_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CSVCMsg_GameEvent_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_GameEvent_key_t_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CSVCMsg_GameEvent_key_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_TempEntities_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CSVCMsg_TempEntities_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_PacketEntities_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CSVCMsg_PacketEntities_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_EntityMsg_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CSVCMsg_EntityMsg_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_CmdKeyValues_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CSVCMsg_CmdKeyValues_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_EncryptedData_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CSVCMsg_EncryptedData_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_HltvReplay_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CSVCMsg_HltvReplay_reflection_ = NULL;
const ::google::protobuf::Descriptor* CCLCMsg_HltvReplay_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CCLCMsg_HltvReplay_reflection_ = NULL;
const ::google::protobuf::Descriptor* CSVCMsg_Broadcast_Command_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  CSVCMsg_Broadcast_Command_reflection_ = NULL;
const ::google::protobuf::EnumDescriptor* NET_Messages_descriptor_ = NULL;
const ::google::protobuf::EnumDescriptor* CLC_Messages_descriptor_ = NULL;
const ::google::protobuf::EnumDescriptor* VoiceDataFormat_t_descriptor_ = NULL;
const ::google::protobuf::EnumDescriptor* ESplitScreenMessageType_descriptor_ = NULL;
const ::google::protobuf::EnumDescriptor* SVC_Messages_descriptor_ = NULL;
const ::google::protobuf::EnumDescriptor* ReplayEventType_t_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);
  CMsgVector_descriptor_ = file->message_type(0);
  static const int CMsgVector_offsets_[3] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgVector, x_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgVector, y_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgVector, z_),
  };
  CMsgVector_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CMsgVector_descriptor_,
      CMsgVector::default_instance_,
      CMsgVector_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgVector, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgVector, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CMsgVector));
  CMsgVector2D_descriptor_ = file->message_type(1);
  static const int CMsgVector2D_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgVector2D, x_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgVector2D, y_),
  };
  CMsgVector2D_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CMsgVector2D_descriptor_,
      CMsgVector2D::default_instance_,
      CMsgVector2D_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgVector2D, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgVector2D, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CMsgVector2D));
  CMsgQAngle_descriptor_ = file->message_type(2);
  static const int CMsgQAngle_offsets_[3] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgQAngle, x_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgQAngle, y_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgQAngle, z_),
  };
  CMsgQAngle_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CMsgQAngle_descriptor_,
      CMsgQAngle::default_instance_,
      CMsgQAngle_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgQAngle, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgQAngle, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CMsgQAngle));
  CMsgRGBA_descriptor_ = file->message_type(3);
  static const int CMsgRGBA_offsets_[4] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgRGBA, r_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgRGBA, g_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgRGBA, b_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgRGBA, a_),
  };
  CMsgRGBA_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CMsgRGBA_descriptor_,
      CMsgRGBA::default_instance_,
      CMsgRGBA_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgRGBA, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsgRGBA, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CMsgRGBA));
  CNETMsg_Tick_descriptor_ = file->message_type(4);
  static const int CNETMsg_Tick_offsets_[5] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CNETMsg_Tick, tick_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CNETMsg_Tick, host_computationtime_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CNETMsg_Tick, host_computationtime_std_deviation_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CNETMsg_Tick, host_framestarttime_std_deviation_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CNETMsg_Tick, hltv_replay_flags_),
  };
  CNETMsg_Tick_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CNETMsg_Tick_descriptor_,
      CNETMsg_Tick::default_instance_,
      CNETMsg_Tick_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CNETMsg_Tick, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CNETMsg_Tick, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CNETMsg_Tick));
  CNETMsg_StringCmd_descriptor_ = file->message_type(5);
  static const int CNETMsg_StringCmd_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CNETMsg_StringCmd, command_),
  };
  CNETMsg_StringCmd_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CNETMsg_StringCmd_descriptor_,
      CNETMsg_StringCmd::default_instance_,
      CNETMsg_StringCmd_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CNETMsg_StringCmd, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CNETMsg_StringCmd, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CNETMsg_StringCmd));
  CNETMsg_SignonState_descriptor_ = file->message_type(6);
  static const int CNETMsg_SignonState_offsets_[5] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CNETMsg_SignonState, signon_state_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CNETMsg_SignonState, spawn_count_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CNETMsg_SignonState, num_server_players_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CNETMsg_SignonState, players_networkids_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CNETMsg_SignonState, map_name_),
  };
  CNETMsg_SignonState_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CNETMsg_SignonState_descriptor_,
      CNETMsg_SignonState::default_instance_,
      CNETMsg_SignonState_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CNETMsg_SignonState, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CNETMsg_SignonState, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CNETMsg_SignonState));
  CMsg_CVars_descriptor_ = file->message_type(7);
  static const int CMsg_CVars_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsg_CVars, cvars_),
  };
  CMsg_CVars_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CMsg_CVars_descriptor_,
      CMsg_CVars::default_instance_,
      CMsg_CVars_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsg_CVars, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsg_CVars, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CMsg_CVars));
  CMsg_CVars_CVar_descriptor_ = CMsg_CVars_descriptor_->nested_type(0);
  static const int CMsg_CVars_CVar_offsets_[3] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsg_CVars_CVar, name_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsg_CVars_CVar, value_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsg_CVars_CVar, dictionary_name_),
  };
  CMsg_CVars_CVar_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CMsg_CVars_CVar_descriptor_,
      CMsg_CVars_CVar::default_instance_,
      CMsg_CVars_CVar_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsg_CVars_CVar, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CMsg_CVars_CVar, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CMsg_CVars_CVar));
  CNETMsg_SetConVar_descriptor_ = file->message_type(8);
  static const int CNETMsg_SetConVar_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CNETMsg_SetConVar, convars_),
  };
  CNETMsg_SetConVar_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CNETMsg_SetConVar_descriptor_,
      CNETMsg_SetConVar::default_instance_,
      CNETMsg_SetConVar_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CNETMsg_SetConVar, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CNETMsg_SetConVar, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CNETMsg_SetConVar));
  CNETMsg_NOP_descriptor_ = file->message_type(9);
  static const int CNETMsg_NOP_offsets_[1] = {
  };
  CNETMsg_NOP_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CNETMsg_NOP_descriptor_,
      CNETMsg_NOP::default_instance_,
      CNETMsg_NOP_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CNETMsg_NOP, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CNETMsg_NOP, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CNETMsg_NOP));
  CNETMsg_Disconnect_descriptor_ = file->message_type(10);
  static const int CNETMsg_Disconnect_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CNETMsg_Disconnect, text_),
  };
  CNETMsg_Disconnect_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CNETMsg_Disconnect_descriptor_,
      CNETMsg_Disconnect::default_instance_,
      CNETMsg_Disconnect_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CNETMsg_Disconnect, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CNETMsg_Disconnect, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CNETMsg_Disconnect));
  CNETMsg_File_descriptor_ = file->message_type(11);
  static const int CNETMsg_File_offsets_[4] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CNETMsg_File, transfer_id_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CNETMsg_File, file_name_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CNETMsg_File, is_replay_demo_file_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CNETMsg_File, deny_),
  };
  CNETMsg_File_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CNETMsg_File_descriptor_,
      CNETMsg_File::default_instance_,
      CNETMsg_File_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CNETMsg_File, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CNETMsg_File, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CNETMsg_File));
  CNETMsg_SplitScreenUser_descriptor_ = file->message_type(12);
  static const int CNETMsg_SplitScreenUser_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CNETMsg_SplitScreenUser, slot_),
  };
  CNETMsg_SplitScreenUser_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CNETMsg_SplitScreenUser_descriptor_,
      CNETMsg_SplitScreenUser::default_instance_,
      CNETMsg_SplitScreenUser_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CNETMsg_SplitScreenUser, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CNETMsg_SplitScreenUser, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CNETMsg_SplitScreenUser));
  CNETMsg_PlayerAvatarData_descriptor_ = file->message_type(13);
  static const int CNETMsg_PlayerAvatarData_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CNETMsg_PlayerAvatarData, accountid_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CNETMsg_PlayerAvatarData, rgb_),
  };
  CNETMsg_PlayerAvatarData_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CNETMsg_PlayerAvatarData_descriptor_,
      CNETMsg_PlayerAvatarData::default_instance_,
      CNETMsg_PlayerAvatarData_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CNETMsg_PlayerAvatarData, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CNETMsg_PlayerAvatarData, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CNETMsg_PlayerAvatarData));
  CCLCMsg_ClientInfo_descriptor_ = file->message_type(14);
  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(15);
  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));
  CCLCMsg_VoiceData_descriptor_ = file->message_type(16);
  static const int CCLCMsg_VoiceData_offsets_[6] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_VoiceData, data_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_VoiceData, xuid_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_VoiceData, format_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_VoiceData, sequence_bytes_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_VoiceData, section_number_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_VoiceData, uncompressed_sample_offset_),
  };
  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(17);
  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(18);
  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(19);
  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(20);
  static const int CCLCMsg_FileCRCCheck_offsets_[11] = {
    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, file_fraction_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_FileCRCCheck, md5_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_FileCRCCheck, crc_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_FileCRCCheck, file_hash_type_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_FileCRCCheck, file_len_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_FileCRCCheck, pack_file_id_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_FileCRCCheck, pack_file_number_),
  };
  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(21);
  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(22);
  static const int CCLCMsg_SplitPlayerConnect_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_SplitPlayerConnect, convars_),
  };
  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_CmdKeyValues_descriptor_ = file->message_type(23);
  static const int CCLCMsg_CmdKeyValues_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_CmdKeyValues, keyvalues_),
  };
  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(24);
  static const int CSVCMsg_ServerInfo_offsets_[22] = {
    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_official_valve_server_),
    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, is_redirecting_to_proxy_relay_),
    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, map_group_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, public_ip_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_ServerInfo, ugc_map_id_),
  };
  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(25);
  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_SendTable_descriptor_ = file->message_type(26);
  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_Print_descriptor_ = file->message_type(27);
  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_SetPause_descriptor_ = file->message_type(28);
  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_SetView_descriptor_ = file->message_type(29);
  static const int CSVCMsg_SetView_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_SetView, entity_index_),
  };
  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_CreateStringTable_descriptor_ = file->message_type(30);
  static const int CSVCMsg_CreateStringTable_offsets_[8] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_CreateStringTable, name_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_CreateStringTable, max_entries_),
    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_),
  };
  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(31);
  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_VoiceInit_descriptor_ = file->message_type(32);
  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_VoiceData_descriptor_ = file->message_type(33);
  static const int CSVCMsg_VoiceData_offsets_[10] = {
    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, voice_data_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_VoiceData, caster_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_VoiceData, format_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_VoiceData, sequence_bytes_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_VoiceData, section_number_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_VoiceData, uncompressed_sample_offset_),
  };
  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_FixAngle_descriptor_ = file->message_type(34);
  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(35);
  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_Prefetch_descriptor_ = file->message_type(36);
  static const int CSVCMsg_Prefetch_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Prefetch, sound_index_),
  };
  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_BSPDecal_descriptor_ = file->message_type(37);
  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(38);
  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(39);
  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(40);
  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_UserMessage_descriptor_ = file->message_type(41);
  static const int CSVCMsg_UserMessage_offsets_[3] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_UserMessage, msg_type_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_UserMessage, msg_data_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_UserMessage, passthrough_),
  };
  CSVCMsg_UserMessage_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CSVCMsg_UserMessage_descriptor_,
      CSVCMsg_UserMessage::default_instance_,
      CSVCMsg_UserMessage_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_UserMessage, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_UserMessage, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CSVCMsg_UserMessage));
  CSVCMsg_PaintmapData_descriptor_ = file->message_type(42);
  static const int CSVCMsg_PaintmapData_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_PaintmapData, paintmap_),
  };
  CSVCMsg_PaintmapData_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CSVCMsg_PaintmapData_descriptor_,
      CSVCMsg_PaintmapData::default_instance_,
      CSVCMsg_PaintmapData_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_PaintmapData, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_PaintmapData, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CSVCMsg_PaintmapData));
  CSVCMsg_GameEvent_descriptor_ = file->message_type(43);
  static const int CSVCMsg_GameEvent_offsets_[4] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_GameEvent, event_name_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_GameEvent, eventid_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_GameEvent, keys_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_GameEvent, passthrough_),
  };
  CSVCMsg_GameEvent_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CSVCMsg_GameEvent_descriptor_,
      CSVCMsg_GameEvent::default_instance_,
      CSVCMsg_GameEvent_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_GameEvent, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_GameEvent, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CSVCMsg_GameEvent));
  CSVCMsg_GameEvent_key_t_descriptor_ = CSVCMsg_GameEvent_descriptor_->nested_type(0);
  static const int CSVCMsg_GameEvent_key_t_offsets_[9] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_GameEvent_key_t, type_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_GameEvent_key_t, val_string_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_GameEvent_key_t, val_float_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_GameEvent_key_t, val_long_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_GameEvent_key_t, val_short_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_GameEvent_key_t, val_byte_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_GameEvent_key_t, val_bool_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_GameEvent_key_t, val_uint64_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_GameEvent_key_t, val_wstring_),
  };
  CSVCMsg_GameEvent_key_t_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CSVCMsg_GameEvent_key_t_descriptor_,
      CSVCMsg_GameEvent_key_t::default_instance_,
      CSVCMsg_GameEvent_key_t_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_GameEvent_key_t, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_GameEvent_key_t, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CSVCMsg_GameEvent_key_t));
  CSVCMsg_GameEventList_descriptor_ = file->message_type(44);
  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_TempEntities_descriptor_ = file->message_type(45);
  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_PacketEntities_descriptor_ = file->message_type(46);
  static const int CSVCMsg_PacketEntities_offsets_[7] = {
    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_),
  };
  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_Sounds_descriptor_ = file->message_type(47);
  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_[17] = {
    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_),
  };
  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_EntityMsg_descriptor_ = file->message_type(48);
  static const int CSVCMsg_EntityMsg_offsets_[3] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_EntityMsg, ent_index_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_EntityMsg, class_id_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_EntityMsg, ent_data_),
  };
  CSVCMsg_EntityMsg_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CSVCMsg_EntityMsg_descriptor_,
      CSVCMsg_EntityMsg::default_instance_,
      CSVCMsg_EntityMsg_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_EntityMsg, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_EntityMsg, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CSVCMsg_EntityMsg));
  CSVCMsg_CmdKeyValues_descriptor_ = file->message_type(49);
  static const int CSVCMsg_CmdKeyValues_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_CmdKeyValues, keyvalues_),
  };
  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));
  CSVCMsg_EncryptedData_descriptor_ = file->message_type(50);
  static const int CSVCMsg_EncryptedData_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_EncryptedData, encrypted_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_EncryptedData, key_type_),
  };
  CSVCMsg_EncryptedData_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CSVCMsg_EncryptedData_descriptor_,
      CSVCMsg_EncryptedData::default_instance_,
      CSVCMsg_EncryptedData_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_EncryptedData, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_EncryptedData, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CSVCMsg_EncryptedData));
  CSVCMsg_HltvReplay_descriptor_ = file->message_type(51);
  static const int CSVCMsg_HltvReplay_offsets_[7] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_HltvReplay, delay_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_HltvReplay, primary_target_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_HltvReplay, replay_stop_at_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_HltvReplay, replay_start_at_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_HltvReplay, replay_slowdown_begin_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_HltvReplay, replay_slowdown_end_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_HltvReplay, replay_slowdown_rate_),
  };
  CSVCMsg_HltvReplay_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CSVCMsg_HltvReplay_descriptor_,
      CSVCMsg_HltvReplay::default_instance_,
      CSVCMsg_HltvReplay_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_HltvReplay, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_HltvReplay, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CSVCMsg_HltvReplay));
  CCLCMsg_HltvReplay_descriptor_ = file->message_type(52);
  static const int CCLCMsg_HltvReplay_offsets_[5] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_HltvReplay, request_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_HltvReplay, slowdown_length_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_HltvReplay, slowdown_rate_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_HltvReplay, primary_target_ent_index_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_HltvReplay, event_time_),
  };
  CCLCMsg_HltvReplay_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CCLCMsg_HltvReplay_descriptor_,
      CCLCMsg_HltvReplay::default_instance_,
      CCLCMsg_HltvReplay_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_HltvReplay, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CCLCMsg_HltvReplay, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CCLCMsg_HltvReplay));
  CSVCMsg_Broadcast_Command_descriptor_ = file->message_type(53);
  static const int CSVCMsg_Broadcast_Command_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Broadcast_Command, cmd_),
  };
  CSVCMsg_Broadcast_Command_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      CSVCMsg_Broadcast_Command_descriptor_,
      CSVCMsg_Broadcast_Command::default_instance_,
      CSVCMsg_Broadcast_Command_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Broadcast_Command, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CSVCMsg_Broadcast_Command, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(CSVCMsg_Broadcast_Command));
  NET_Messages_descriptor_ = file->enum_type(0);
  CLC_Messages_descriptor_ = file->enum_type(1);
  VoiceDataFormat_t_descriptor_ = file->enum_type(2);
  ESplitScreenMessageType_descriptor_ = file->enum_type(3);
  SVC_Messages_descriptor_ = file->enum_type(4);
  ReplayEventType_t_descriptor_ = file->enum_type(5);
}

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(
    CMsgVector_descriptor_, &CMsgVector::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CMsgVector2D_descriptor_, &CMsgVector2D::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CMsgQAngle_descriptor_, &CMsgQAngle::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CMsgRGBA_descriptor_, &CMsgRGBA::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CNETMsg_Tick_descriptor_, &CNETMsg_Tick::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CNETMsg_StringCmd_descriptor_, &CNETMsg_StringCmd::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CNETMsg_SignonState_descriptor_, &CNETMsg_SignonState::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CMsg_CVars_descriptor_, &CMsg_CVars::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CMsg_CVars_CVar_descriptor_, &CMsg_CVars_CVar::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CNETMsg_SetConVar_descriptor_, &CNETMsg_SetConVar::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CNETMsg_NOP_descriptor_, &CNETMsg_NOP::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CNETMsg_Disconnect_descriptor_, &CNETMsg_Disconnect::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CNETMsg_File_descriptor_, &CNETMsg_File::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CNETMsg_SplitScreenUser_descriptor_, &CNETMsg_SplitScreenUser::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CNETMsg_PlayerAvatarData_descriptor_, &CNETMsg_PlayerAvatarData::default_instance());
  ::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(
    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_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_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_Print_descriptor_, &CSVCMsg_Print::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CSVCMsg_SetPause_descriptor_, &CSVCMsg_SetPause::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CSVCMsg_SetView_descriptor_, &CSVCMsg_SetView::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_VoiceInit_descriptor_, &CSVCMsg_VoiceInit::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CSVCMsg_VoiceData_descriptor_, &CSVCMsg_VoiceData::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_Prefetch_descriptor_, &CSVCMsg_Prefetch::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_UserMessage_descriptor_, &CSVCMsg_UserMessage::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CSVCMsg_PaintmapData_descriptor_, &CSVCMsg_PaintmapData::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CSVCMsg_GameEvent_descriptor_, &CSVCMsg_GameEvent::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CSVCMsg_GameEvent_key_t_descriptor_, &CSVCMsg_GameEvent_key_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_TempEntities_descriptor_, &CSVCMsg_TempEntities::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CSVCMsg_PacketEntities_descriptor_, &CSVCMsg_PacketEntities::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_EntityMsg_descriptor_, &CSVCMsg_EntityMsg::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CSVCMsg_CmdKeyValues_descriptor_, &CSVCMsg_CmdKeyValues::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CSVCMsg_EncryptedData_descriptor_, &CSVCMsg_EncryptedData::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CSVCMsg_HltvReplay_descriptor_, &CSVCMsg_HltvReplay::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CCLCMsg_HltvReplay_descriptor_, &CCLCMsg_HltvReplay::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    CSVCMsg_Broadcast_Command_descriptor_, &CSVCMsg_Broadcast_Command::default_instance());
}

}  // namespace

void protobuf_ShutdownFile_netmessages_2eproto() {
  delete CMsgVector::default_instance_;
  delete CMsgVector_reflection_;
  delete CMsgVector2D::default_instance_;
  delete CMsgVector2D_reflection_;
  delete CMsgQAngle::default_instance_;
  delete CMsgQAngle_reflection_;
  delete CMsgRGBA::default_instance_;
  delete CMsgRGBA_reflection_;
  delete CNETMsg_Tick::default_instance_;
  delete CNETMsg_Tick_reflection_;
  delete CNETMsg_StringCmd::default_instance_;
  delete CNETMsg_StringCmd_reflection_;
  delete CNETMsg_SignonState::default_instance_;
  delete CNETMsg_SignonState_reflection_;
  delete CMsg_CVars::default_instance_;
  delete CMsg_CVars_reflection_;
  delete CMsg_CVars_CVar::default_instance_;
  delete CMsg_CVars_CVar_reflection_;
  delete CNETMsg_SetConVar::default_instance_;
  delete CNETMsg_SetConVar_reflection_;
  delete CNETMsg_NOP::default_instance_;
  delete CNETMsg_NOP_reflection_;
  delete CNETMsg_Disconnect::default_instance_;
  delete CNETMsg_Disconnect_reflection_;
  delete CNETMsg_File::default_instance_;
  delete CNETMsg_File_reflection_;
  delete CNETMsg_SplitScreenUser::default_instance_;
  delete CNETMsg_SplitScreenUser_reflection_;
  delete CNETMsg_PlayerAvatarData::default_instance_;
  delete CNETMsg_PlayerAvatarData_reflection_;
  delete CCLCMsg_ClientInfo::default_instance_;
  delete CCLCMsg_ClientInfo_reflection_;
  delete CCLCMsg_Move::default_instance_;
  delete CCLCMsg_Move_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_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_SendTable::default_instance_;
  delete CSVCMsg_SendTable_reflection_;
  delete CSVCMsg_SendTable_sendprop_t::default_instance_;
  delete CSVCMsg_SendTable_sendprop_t_reflection_;
  delete CSVCMsg_Print::default_instance_;
  delete CSVCMsg_Print_reflection_;
  delete CSVCMsg_SetPause::default_instance_;
  delete CSVCMsg_SetPause_reflection_;
  delete CSVCMsg_SetView::default_instance_;
  delete CSVCMsg_SetView_reflection_;
  delete CSVCMsg_CreateStringTable::default_instance_;
  delete CSVCMsg_CreateStringTable_reflection_;
  delete CSVCMsg_UpdateStringTable::default_instance_;
  delete CSVCMsg_UpdateStringTable_reflection_;
  delete CSVCMsg_VoiceInit::default_instance_;
  delete CSVCMsg_VoiceInit_reflection_;
  delete CSVCMsg_VoiceData::default_instance_;
  delete CSVCMsg_VoiceData_reflection_;
  delete CSVCMsg_FixAngle::default_instance_;
  delete CSVCMsg_FixAngle_reflection_;
  delete CSVCMsg_CrosshairAngle::default_instance_;
  delete CSVCMsg_CrosshairAngle_reflection_;
  delete CSVCMsg_Prefetch::default_instance_;
  delete CSVCMsg_Prefetch_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_UserMessage::default_instance_;
  delete CSVCMsg_UserMessage_reflection_;
  delete CSVCMsg_PaintmapData::default_instance_;
  delete CSVCMsg_PaintmapData_reflection_;
  delete CSVCMsg_GameEvent::default_instance_;
  delete CSVCMsg_GameEvent_reflection_;
  delete CSVCMsg_GameEvent_key_t::default_instance_;
  delete CSVCMsg_GameEvent_key_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_TempEntities::default_instance_;
  delete CSVCMsg_TempEntities_reflection_;
  delete CSVCMsg_PacketEntities::default_instance_;
  delete CSVCMsg_PacketEntities_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_EntityMsg::default_instance_;
  delete CSVCMsg_EntityMsg_reflection_;
  delete CSVCMsg_CmdKeyValues::default_instance_;
  delete CSVCMsg_CmdKeyValues_reflection_;
  delete CSVCMsg_EncryptedData::default_instance_;
  delete CSVCMsg_EncryptedData_reflection_;
  delete CSVCMsg_HltvReplay::default_instance_;
  delete CSVCMsg_HltvReplay_reflection_;
  delete CCLCMsg_HltvReplay::default_instance_;
  delete CCLCMsg_HltvReplay_reflection_;
  delete CSVCMsg_Broadcast_Command::default_instance_;
  delete CSVCMsg_Broadcast_Command_reflection_;
}

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

  ::google::protobuf::protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();
  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
    "\n\021netmessages.proto\032 google/protobuf/des"
    "criptor.proto\"-\n\nCMsgVector\022\t\n\001x\030\001 \001(\002\022\t"
    "\n\001y\030\002 \001(\002\022\t\n\001z\030\003 \001(\002\"$\n\014CMsgVector2D\022\t\n\001"
    "x\030\001 \001(\002\022\t\n\001y\030\002 \001(\002\"-\n\nCMsgQAngle\022\t\n\001x\030\001 "
    "\001(\002\022\t\n\001y\030\002 \001(\002\022\t\n\001z\030\003 \001(\002\"6\n\010CMsgRGBA\022\t\n"
    "\001r\030\001 \001(\005\022\t\n\001g\030\002 \001(\005\022\t\n\001b\030\003 \001(\005\022\t\n\001a\030\004 \001("
    "\005\"\254\001\n\014CNETMsg_Tick\022\014\n\004tick\030\001 \001(\r\022\034\n\024host"
    "_computationtime\030\004 \001(\r\022*\n\"host_computati"
    "ontime_std_deviation\030\005 \001(\r\022)\n!host_frame"
    "starttime_std_deviation\030\006 \001(\r\022\031\n\021hltv_re"
    "play_flags\030\007 \001(\r\"$\n\021CNETMsg_StringCmd\022\017\n"
    "\007command\030\001 \001(\t\"\212\001\n\023CNETMsg_SignonState\022\024"
    "\n\014signon_state\030\001 \001(\r\022\023\n\013spawn_count\030\002 \001("
    "\r\022\032\n\022num_server_players\030\003 \001(\r\022\032\n\022players"
    "_networkids\030\004 \003(\t\022\020\n\010map_name\030\005 \001(\t\"k\n\nC"
    "Msg_CVars\022\037\n\005cvars\030\001 \003(\0132\020.CMsg_CVars.CV"
    "ar\032<\n\004CVar\022\014\n\004name\030\001 \001(\t\022\r\n\005value\030\002 \001(\t\022"
    "\027\n\017dictionary_name\030\003 \001(\r\"1\n\021CNETMsg_SetC"
    "onVar\022\034\n\007convars\030\001 \001(\0132\013.CMsg_CVars\"\r\n\013C"
    "NETMsg_NOP\"\"\n\022CNETMsg_Disconnect\022\014\n\004text"
    "\030\001 \001(\t\"a\n\014CNETMsg_File\022\023\n\013transfer_id\030\001 "
    "\001(\005\022\021\n\tfile_name\030\002 \001(\t\022\033\n\023is_replay_demo"
    "_file\030\003 \001(\010\022\014\n\004deny\030\004 \001(\010\"\'\n\027CNETMsg_Spl"
    "itScreenUser\022\014\n\004slot\030\001 \001(\005\":\n\030CNETMsg_Pl"
    "ayerAvatarData\022\021\n\taccountid\030\001 \001(\r\022\013\n\003rgb"
    "\030\002 \001(\014\"\246\001\n\022CCLCMsg_ClientInfo\022\026\n\016send_ta"
    "ble_crc\030\001 \001(\007\022\024\n\014server_count\030\002 \001(\r\022\017\n\007i"
    "s_hltv\030\003 \001(\010\022\021\n\tis_replay\030\004 \001(\010\022\022\n\nfrien"
    "ds_id\030\005 \001(\r\022\024\n\014friends_name\030\006 \001(\t\022\024\n\014cus"
    "tom_files\030\007 \003(\007\"S\n\014CCLCMsg_Move\022\033\n\023num_b"
    "ackup_commands\030\001 \001(\r\022\030\n\020num_new_commands"
    "\030\002 \001(\r\022\014\n\004data\030\003 \001(\014\"\300\001\n\021CCLCMsg_VoiceDa"
    "ta\022\014\n\004data\030\001 \001(\014\022\014\n\004xuid\030\002 \001(\006\022;\n\006format"
    "\030\003 \001(\0162\022.VoiceDataFormat_t:\027VOICEDATA_FO"
    "RMAT_ENGINE\022\026\n\016sequence_bytes\030\004 \001(\005\022\026\n\016s"
    "ection_number\030\005 \001(\r\022\"\n\032uncompressed_samp"
    "le_offset\030\006 \001(\r\"A\n\023CCLCMsg_BaselineAck\022\025"
    "\n\rbaseline_tick\030\001 \001(\005\022\023\n\013baseline_nr\030\002 \001"
    "(\005\"*\n\024CCLCMsg_ListenEvents\022\022\n\nevent_mask"
    "\030\001 \003(\007\"\\\n\030CCLCMsg_RespondCvarValue\022\016\n\006co"
    "okie\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\"\353\001\n\024CCLCMsg_FileCRC"
    "Check\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"
    "\025\n\rfile_fraction\030\005 \001(\005\022\013\n\003md5\030\006 \001(\014\022\013\n\003c"
    "rc\030\007 \001(\r\022\026\n\016file_hash_type\030\010 \001(\005\022\020\n\010file"
    "_len\030\t \001(\005\022\024\n\014pack_file_id\030\n \001(\005\022\030\n\020pack"
    "_file_number\030\013 \001(\005\"+\n\027CCLCMsg_LoadingPro"
    "gress\022\020\n\010progress\030\001 \001(\005\":\n\032CCLCMsg_Split"
    "PlayerConnect\022\034\n\007convars\030\001 \001(\0132\013.CMsg_CV"
    "ars\")\n\024CCLCMsg_CmdKeyValues\022\021\n\tkeyvalues"
    "\030\001 \001(\014\"\352\003\n\022CSVCMsg_ServerInfo\022\020\n\010protoco"
    "l\030\001 \001(\005\022\024\n\014server_count\030\002 \001(\005\022\024\n\014is_dedi"
    "cated\030\003 \001(\010\022 \n\030is_official_valve_server\030"
    "\004 \001(\010\022\017\n\007is_hltv\030\005 \001(\010\022\021\n\tis_replay\030\006 \001("
    "\010\022%\n\035is_redirecting_to_proxy_relay\030\025 \001(\010"
    "\022\014\n\004c_os\030\007 \001(\005\022\017\n\007map_crc\030\010 \001(\007\022\022\n\nclien"
    "t_crc\030\t \001(\007\022\030\n\020string_table_crc\030\n \001(\007\022\023\n"
    "\013max_clients\030\013 \001(\005\022\023\n\013max_classes\030\014 \001(\005\022"
    "\023\n\013player_slot\030\r \001(\005\022\025\n\rtick_interval\030\016 "
    "\001(\002\022\020\n\010game_dir\030\017 \001(\t\022\020\n\010map_name\030\020 \001(\t\022"
    "\026\n\016map_group_name\030\021 \001(\t\022\020\n\010sky_name\030\022 \001("
    "\t\022\021\n\thost_name\030\023 \001(\t\022\021\n\tpublic_ip\030\024 \001(\r\022"
    "\022\n\nugc_map_id\030\026 \001(\004\"\244\001\n\021CSVCMsg_ClassInf"
    "o\022\030\n\020create_on_client\030\001 \001(\010\022+\n\007classes\030\002"
    " \003(\0132\032.CSVCMsg_ClassInfo.class_t\032H\n\007clas"
    "s_t\022\020\n\010class_id\030\001 \001(\005\022\027\n\017data_table_name"
    "\030\002 \001(\t\022\022\n\nclass_name\030\003 \001(\t\"\260\002\n\021CSVCMsg_S"
    "endTable\022\016\n\006is_end\030\001 \001(\010\022\026\n\016net_table_na"
    "me\030\002 \001(\t\022\025\n\rneeds_decoder\030\003 \001(\010\022,\n\005props"
    "\030\004 \003(\0132\035.CSVCMsg_SendTable.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\t"
    "low_value\030\007 \001(\002\022\022\n\nhigh_value\030\010 \001(\002\022\020\n\010n"
    "um_bits\030\t \001(\005\"\035\n\rCSVCMsg_Print\022\014\n\004text\030\001"
    " \001(\t\"\"\n\020CSVCMsg_SetPause\022\016\n\006paused\030\001 \001(\010"
    "\"\'\n\017CSVCMsg_SetView\022\024\n\014entity_index\030\001 \001("
    "\005\"\312\001\n\031CSVCMsg_CreateStringTable\022\014\n\004name\030"
    "\001 \001(\t\022\023\n\013max_entries\030\002 \001(\005\022\023\n\013num_entrie"
    "s\030\003 \001(\005\022\034\n\024user_data_fixed_size\030\004 \001(\010\022\026\n"
    "\016user_data_size\030\005 \001(\005\022\033\n\023user_data_size_"
    "bits\030\006 \001(\005\022\r\n\005flags\030\007 \001(\005\022\023\n\013string_data"
    "\030\010 \001(\014\"_\n\031CSVCMsg_UpdateStringTable\022\020\n\010t"
    "able_id\030\001 \001(\005\022\033\n\023num_changed_entries\030\002 \001"
    "(\005\022\023\n\013string_data\030\003 \001(\014\"G\n\021CSVCMsg_Voice"
    "Init\022\017\n\007quality\030\001 \001(\005\022\r\n\005codec\030\002 \001(\t\022\022\n\007"
    "version\030\003 \001(\005:\0010\"\217\002\n\021CSVCMsg_VoiceData\022\016"
    "\n\006client\030\001 \001(\005\022\021\n\tproximity\030\002 \001(\010\022\014\n\004xui"
    "d\030\003 \001(\006\022\024\n\014audible_mask\030\004 \001(\005\022\022\n\nvoice_d"
    "ata\030\005 \001(\014\022\016\n\006caster\030\006 \001(\010\022;\n\006format\030\007 \001("
    "\0162\022.VoiceDataFormat_t:\027VOICEDATA_FORMAT_"
    "ENGINE\022\026\n\016sequence_bytes\030\010 \001(\005\022\026\n\016sectio"
    "n_number\030\t \001(\r\022\"\n\032uncompressed_sample_of"
    "fset\030\n \001(\r\"@\n\020CSVCMsg_FixAngle\022\020\n\010relati"
    "ve\030\001 \001(\010\022\032\n\005angle\030\002 \001(\0132\013.CMsgQAngle\"4\n\026"
    "CSVCMsg_CrosshairAngle\022\032\n\005angle\030\001 \001(\0132\013."
    "CMsgQAngle\"\'\n\020CSVCMsg_Prefetch\022\023\n\013sound_"
    "index\030\001 \001(\005\"\212\001\n\020CSVCMsg_BSPDecal\022\030\n\003pos\030"
    "\001 \001(\0132\013.CMsgVector\022\033\n\023decal_texture_inde"
    "x\030\002 \001(\005\022\024\n\014entity_index\030\003 \001(\005\022\023\n\013model_i"
    "ndex\030\004 \001(\005\022\024\n\014low_priority\030\005 \001(\010\"a\n\023CSVC"
    "Msg_SplitScreen\022&\n\004type\030\001 \001(\0162\030.ESplitSc"
    "reenMessageType\022\014\n\004slot\030\002 \001(\005\022\024\n\014player_"
    "index\030\003 \001(\005\"9\n\024CSVCMsg_GetCvarValue\022\016\n\006c"
    "ookie\030\001 \001(\005\022\021\n\tcvar_name\030\002 \001(\t\"<\n\014CSVCMs"
    "g_Menu\022\023\n\013dialog_type\030\001 \001(\005\022\027\n\017menu_key_"
    "values\030\002 \001(\014\"N\n\023CSVCMsg_UserMessage\022\020\n\010m"
    "sg_type\030\001 \001(\005\022\020\n\010msg_data\030\002 \001(\014\022\023\n\013passt"
    "hrough\030\003 \001(\005\"(\n\024CSVCMsg_PaintmapData\022\020\n\010"
    "paintmap\030\001 \001(\014\"\246\002\n\021CSVCMsg_GameEvent\022\022\n\n"
    "event_name\030\001 \001(\t\022\017\n\007eventid\030\002 \001(\005\022&\n\004key"
    "s\030\003 \003(\0132\030.CSVCMsg_GameEvent.key_t\022\023\n\013pas"
    "sthrough\030\004 \001(\005\032\256\001\n\005key_t\022\014\n\004type\030\001 \001(\005\022\022"
    "\n\nval_string\030\002 \001(\t\022\021\n\tval_float\030\003 \001(\002\022\020\n"
    "\010val_long\030\004 \001(\005\022\021\n\tval_short\030\005 \001(\005\022\020\n\010va"
    "l_byte\030\006 \001(\005\022\020\n\010val_bool\030\007 \001(\010\022\022\n\nval_ui"
    "nt64\030\010 \001(\004\022\023\n\013val_wstring\030\t \001(\014\"\321\001\n\025CSVC"
    "Msg_GameEventList\0228\n\013descriptors\030\001 \003(\0132#"
    ".CSVCMsg_GameEventList.descriptor_t\032#\n\005k"
    "ey_t\022\014\n\004type\030\001 \001(\005\022\014\n\004name\030\002 \001(\t\032Y\n\014desc"
    "riptor_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.ke"
    "y_t\"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_dat"
    "a\030\003 \001(\014\"\254\001\n\026CSVCMsg_PacketEntities\022\023\n\013ma"
    "x_entries\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\"\266\003\n\016CSVCMsg_Sound"
    "s\022\026\n\016reliable_sound\030\001 \001(\010\022+\n\006sounds\030\002 \003("
    "\0132\033.CSVCMsg_Sounds.sounddata_t\032\336\002\n\013sound"
    "data_t\022\020\n\010origin_x\030\001 \001(\021\022\020\n\010origin_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\013"
    "delay_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\007channel\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\016"
    "speaker_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_sentence\030\020 "
    "\001(\010\022\022\n\nis_ambient\030\021 \001(\010\"J\n\021CSVCMsg_Entit"
    "yMsg\022\021\n\tent_index\030\001 \001(\005\022\020\n\010class_id\030\002 \001("
    "\005\022\020\n\010ent_data\030\003 \001(\014\")\n\024CSVCMsg_CmdKeyVal"
    "ues\022\021\n\tkeyvalues\030\001 \001(\014\"<\n\025CSVCMsg_Encryp"
    "tedData\022\021\n\tencrypted\030\001 \001(\014\022\020\n\010key_type\030\002"
    " \001(\005\"\306\001\n\022CSVCMsg_HltvReplay\022\r\n\005delay\030\001 \001"
    "(\005\022\026\n\016primary_target\030\002 \001(\005\022\026\n\016replay_sto"
    "p_at\030\003 \001(\005\022\027\n\017replay_start_at\030\004 \001(\005\022\035\n\025r"
    "eplay_slowdown_begin\030\005 \001(\005\022\033\n\023replay_slo"
    "wdown_end\030\006 \001(\005\022\034\n\024replay_slowdown_rate\030"
    "\007 \001(\002\"\213\001\n\022CCLCMsg_HltvReplay\022\017\n\007request\030"
    "\001 \001(\005\022\027\n\017slowdown_length\030\002 \001(\002\022\025\n\rslowdo"
    "wn_rate\030\003 \001(\002\022 \n\030primary_target_ent_inde"
    "x\030\004 \001(\005\022\022\n\nevent_time\030\005 \001(\002\"(\n\031CSVCMsg_B"
    "roadcast_Command\022\013\n\003cmd\030\001 \001(\t*\271\001\n\014NET_Me"
    "ssages\022\013\n\007net_NOP\020\000\022\022\n\016net_Disconnect\020\001\022"
    "\014\n\010net_File\020\002\022\027\n\023net_SplitScreenUser\020\003\022\014"
    "\n\010net_Tick\020\004\022\021\n\rnet_StringCmd\020\005\022\021\n\rnet_S"
    "etConVar\020\006\022\023\n\017net_SignonState\020\007\022\030\n\024net_P"
    "layerAvatarData\020d*\224\002\n\014CLC_Messages\022\022\n\016cl"
    "c_ClientInfo\020\010\022\014\n\010clc_Move\020\t\022\021\n\rclc_Voic"
    "eData\020\n\022\023\n\017clc_BaselineAck\020\013\022\024\n\020clc_List"
    "enEvents\020\014\022\030\n\024clc_RespondCvarValue\020\r\022\024\n\020"
    "clc_FileCRCCheck\020\016\022\027\n\023clc_LoadingProgres"
    "s\020\017\022\032\n\026clc_SplitPlayerConnect\020\020\022\025\n\021clc_C"
    "lientMessage\020\021\022\024\n\020clc_CmdKeyValues\020\022\022\022\n\016"
    "clc_HltvReplay\020\024*L\n\021VoiceDataFormat_t\022\032\n"
    "\026VOICEDATA_FORMAT_STEAM\020\000\022\033\n\027VOICEDATA_F"
    "ORMAT_ENGINE\020\001*y\n\027ESplitScreenMessageTyp"
    "e\022\033\n\027MSG_SPLITSCREEN_ADDUSER\020\000\022\036\n\032MSG_SP"
    "LITSCREEN_REMOVEUSER\020\001\022\035\n\031MSG_SPLITSCREE"
    "N_TYPE_BITS\020\001\032\002\020\001*\343\004\n\014SVC_Messages\022\022\n\016sv"
    "c_ServerInfo\020\010\022\021\n\rsvc_SendTable\020\t\022\021\n\rsvc"
    "_ClassInfo\020\n\022\020\n\014svc_SetPause\020\013\022\031\n\025svc_Cr"
    "eateStringTable\020\014\022\031\n\025svc_UpdateStringTab"
    "le\020\r\022\021\n\rsvc_VoiceInit\020\016\022\021\n\rsvc_VoiceData"
    "\020\017\022\r\n\tsvc_Print\020\020\022\016\n\nsvc_Sounds\020\021\022\017\n\013svc"
    "_SetView\020\022\022\020\n\014svc_FixAngle\020\023\022\026\n\022svc_Cros"
    "shairAngle\020\024\022\020\n\014svc_BSPDecal\020\025\022\023\n\017svc_Sp"
    "litScreen\020\026\022\023\n\017svc_UserMessage\020\027\022\025\n\021svc_"
    "EntityMessage\020\030\022\021\n\rsvc_GameEvent\020\031\022\026\n\022sv"
    "c_PacketEntities\020\032\022\024\n\020svc_TempEntities\020\033"
    "\022\020\n\014svc_Prefetch\020\034\022\014\n\010svc_Menu\020\035\022\025\n\021svc_"
    "GameEventList\020\036\022\024\n\020svc_GetCvarValue\020\037\022\024\n"
    "\020svc_PaintmapData\020!\022\024\n\020svc_CmdKeyValues\020"
    "\"\022\025\n\021svc_EncryptedData\020#\022\022\n\016svc_HltvRepl"
    "ay\020$\022\031\n\025svc_Broadcast_Command\020&*\207\001\n\021Repl"
    "ayEventType_t\022\027\n\023REPLAY_EVENT_CANCEL\020\000\022\026"
    "\n\022REPLAY_EVENT_DEATH\020\001\022\030\n\024REPLAY_EVENT_G"
    "ENERIC\020\002\022\'\n#REPLAY_EVENT_STUCK_NEED_FULL"
    "_UPDATE\020\003B\003\200\001\000", 7614);
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
    "netmessages.proto", &protobuf_RegisterTypes);
  CMsgVector::default_instance_ = new CMsgVector();
  CMsgVector2D::default_instance_ = new CMsgVector2D();
  CMsgQAngle::default_instance_ = new CMsgQAngle();
  CMsgRGBA::default_instance_ = new CMsgRGBA();
  CNETMsg_Tick::default_instance_ = new CNETMsg_Tick();
  CNETMsg_StringCmd::default_instance_ = new CNETMsg_StringCmd();
  CNETMsg_SignonState::default_instance_ = new CNETMsg_SignonState();
  CMsg_CVars::default_instance_ = new CMsg_CVars();
  CMsg_CVars_CVar::default_instance_ = new CMsg_CVars_CVar();
  CNETMsg_SetConVar::default_instance_ = new CNETMsg_SetConVar();
  CNETMsg_NOP::default_instance_ = new CNETMsg_NOP();
  CNETMsg_Disconnect::default_instance_ = new CNETMsg_Disconnect();
  CNETMsg_File::default_instance_ = new CNETMsg_File();
  CNETMsg_SplitScreenUser::default_instance_ = new CNETMsg_SplitScreenUser();
  CNETMsg_PlayerAvatarData::default_instance_ = new CNETMsg_PlayerAvatarData();
  CCLCMsg_ClientInfo::default_instance_ = new CCLCMsg_ClientInfo();
  CCLCMsg_Move::default_instance_ = new CCLCMsg_Move();
  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_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_SendTable::default_instance_ = new CSVCMsg_SendTable();
  CSVCMsg_SendTable_sendprop_t::default_instance_ = new CSVCMsg_SendTable_sendprop_t();
  CSVCMsg_Print::default_instance_ = new CSVCMsg_Print();
  CSVCMsg_SetPause::default_instance_ = new CSVCMsg_SetPause();
  CSVCMsg_SetView::default_instance_ = new CSVCMsg_SetView();
  CSVCMsg_CreateStringTable::default_instance_ = new CSVCMsg_CreateStringTable();
  CSVCMsg_UpdateStringTable::default_instance_ = new CSVCMsg_UpdateStringTable();
  CSVCMsg_VoiceInit::default_instance_ = new CSVCMsg_VoiceInit();
  CSVCMsg_VoiceData::default_instance_ = new CSVCMsg_VoiceData();
  CSVCMsg_FixAngle::default_instance_ = new CSVCMsg_FixAngle();
  CSVCMsg_CrosshairAngle::default_instance_ = new CSVCMsg_CrosshairAngle();
  CSVCMsg_Prefetch::default_instance_ = new CSVCMsg_Prefetch();
  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_UserMessage::default_instance_ = new CSVCMsg_UserMessage();
  CSVCMsg_PaintmapData::default_instance_ = new CSVCMsg_PaintmapData();
  CSVCMsg_GameEvent::default_instance_ = new CSVCMsg_GameEvent();
  CSVCMsg_GameEvent_key_t::default_instance_ = new CSVCMsg_GameEvent_key_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_TempEntities::default_instance_ = new CSVCMsg_TempEntities();
  CSVCMsg_PacketEntities::default_instance_ = new CSVCMsg_PacketEntities();
  CSVCMsg_Sounds::default_instance_ = new CSVCMsg_Sounds();
  CSVCMsg_Sounds_sounddata_t::default_instance_ = new CSVCMsg_Sounds_sounddata_t();
  CSVCMsg_EntityMsg::default_instance_ = new CSVCMsg_EntityMsg();
  CSVCMsg_CmdKeyValues::default_instance_ = new CSVCMsg_CmdKeyValues();
  CSVCMsg_EncryptedData::default_instance_ = new CSVCMsg_EncryptedData();
  CSVCMsg_HltvReplay::default_instance_ = new CSVCMsg_HltvReplay();
  CCLCMsg_HltvReplay::default_instance_ = new CCLCMsg_HltvReplay();
  CSVCMsg_Broadcast_Command::default_instance_ = new CSVCMsg_Broadcast_Command();
  CMsgVector::default_instance_->InitAsDefaultInstance();
  CMsgVector2D::default_instance_->InitAsDefaultInstance();
  CMsgQAngle::default_instance_->InitAsDefaultInstance();
  CMsgRGBA::default_instance_->InitAsDefaultInstance();
  CNETMsg_Tick::default_instance_->InitAsDefaultInstance();
  CNETMsg_StringCmd::default_instance_->InitAsDefaultInstance();
  CNETMsg_SignonState::default_instance_->InitAsDefaultInstance();
  CMsg_CVars::default_instance_->InitAsDefaultInstance();
  CMsg_CVars_CVar::default_instance_->InitAsDefaultInstance();
  CNETMsg_SetConVar::default_instance_->InitAsDefaultInstance();
  CNETMsg_NOP::default_instance_->InitAsDefaultInstance();
  CNETMsg_Disconnect::default_instance_->InitAsDefaultInstance();
  CNETMsg_File::default_instance_->InitAsDefaultInstance();
  CNETMsg_SplitScreenUser::default_instance_->InitAsDefaultInstance();
  CNETMsg_PlayerAvatarData::default_instance_->InitAsDefaultInstance();
  CCLCMsg_ClientInfo::default_instance_->InitAsDefaultInstance();
  CCLCMsg_Move::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_CmdKeyValues::default_instance_->InitAsDefaultInstance();
  CSVCMsg_ServerInfo::default_instance_->InitAsDefaultInstance();
  CSVCMsg_ClassInfo::default_instance_->InitAsDefaultInstance();
  CSVCMsg_ClassInfo_class_t::default_instance_->InitAsDefaultInstance();
  CSVCMsg_SendTable::default_instance_->InitAsDefaultInstance();
  CSVCMsg_SendTable_sendprop_t::default_instance_->InitAsDefaultInstance();
  CSVCMsg_Print::default_instance_->InitAsDefaultInstance();
  CSVCMsg_SetPause::default_instance_->InitAsDefaultInstance();
  CSVCMsg_SetView::default_instance_->InitAsDefaultInstance();
  CSVCMsg_CreateStringTable::default_instance_->InitAsDefaultInstance();
  CSVCMsg_UpdateStringTable::default_instance_->InitAsDefaultInstance();
  CSVCMsg_VoiceInit::default_instance_->InitAsDefaultInstance();
  CSVCMsg_VoiceData::default_instance_->InitAsDefaultInstance();
  CSVCMsg_FixAngle::default_instance_->InitAsDefaultInstance();
  CSVCMsg_CrosshairAngle::default_instance_->InitAsDefaultInstance();
  CSVCMsg_Prefetch::default_instance_->InitAsDefaultInstance();
  CSVCMsg_BSPDecal::default_instance_->InitAsDefaultInstance();
  CSVCMsg_SplitScreen::default_instance_->InitAsDefaultInstance();
  CSVCMsg_GetCvarValue::default_instance_->InitAsDefaultInstance();
  CSVCMsg_Menu::default_instance_->InitAsDefaultInstance();
  CSVCMsg_UserMessage::default_instance_->InitAsDefaultInstance();
  CSVCMsg_PaintmapData::default_instance_->InitAsDefaultInstance();
  CSVCMsg_GameEvent::default_instance_->InitAsDefaultInstance();
  CSVCMsg_GameEvent_key_t::default_instance_->InitAsDefaultInstance();
  CSVCMsg_GameEventList::default_instance_->InitAsDefaultInstance();
  CSVCMsg_GameEventList_key_t::default_instance_->InitAsDefaultInstance();
  CSVCMsg_GameEventList_descriptor_t::default_instance_->InitAsDefaultInstance();
  CSVCMsg_TempEntities::default_instance_->InitAsDefaultInstance();
  CSVCMsg_PacketEntities::default_instance_->InitAsDefaultInstance();
  CSVCMsg_Sounds::default_instance_->InitAsDefaultInstance();
  CSVCMsg_Sounds_sounddata_t::default_instance_->InitAsDefaultInstance();
  CSVCMsg_EntityMsg::default_instance_->InitAsDefaultInstance();
  CSVCMsg_CmdKeyValues::default_instance_->InitAsDefaultInstance();
  CSVCMsg_EncryptedData::default_instance_->InitAsDefaultInstance();
  CSVCMsg_HltvReplay::default_instance_->InitAsDefaultInstance();
  CCLCMsg_HltvReplay::default_instance_->InitAsDefaultInstance();
  CSVCMsg_Broadcast_Command::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* NET_Messages_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return NET_Messages_descriptor_;
}
bool NET_Messages_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
    case 7:
    case 100:
      return true;
    default:
      return false;
  }
}

const ::google::protobuf::EnumDescriptor* CLC_Messages_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return CLC_Messages_descriptor_;
}
bool CLC_Messages_IsValid(int value) {
  switch(value) {
    case 8:
    case 9:
    case 10:
    case 11:
    case 12:
    case 13:
    case 14:
    case 15:
    case 16:
    case 17:
    case 18:
    case 20:
      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* 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* SVC_Messages_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return SVC_Messages_descriptor_;
}
bool SVC_Messages_IsValid(int value) {
  switch(value) {
    case 8:
    case 9:
    case 10:
    case 11:
    case 12:
    case 13:
    case 14:
    case 15:
    case 16:
    case 17:
    case 18:
    case 19:
    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 33:
    case 34:
    case 35:
    case 36:
    case 38:
      return true;
    default:
      return false;
  }
}

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


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

#ifndef _MSC_VER
const int CMsgVector::kXFieldNumber;
const int CMsgVector::kYFieldNumber;
const int CMsgVector::kZFieldNumber;
#endif  // !_MSC_VER

CMsgVector::CMsgVector()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void CMsgVector::InitAsDefaultInstance() {
}

CMsgVector::CMsgVector(const CMsgVector& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void CMsgVector::SharedCtor() {
  _cached_size_ = 0;
  x_ = 0;
  y_ = 0;
  z_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CMsgVector::~CMsgVector() {
  SharedDtor();
}

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

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

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

CMsgVector* CMsgVector::default_instance_ = NULL;

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

void CMsgVector::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    x_ = 0;
    y_ = 0;
    z_ = 0;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool CMsgVector::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional float x = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &x_)));
          set_has_x();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(21)) goto parse_y;
        break;
      }

      // optional float y = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
         parse_y:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &y_)));
          set_has_y();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(29)) goto parse_z;
        break;
      }

      // optional float z = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
         parse_z:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &z_)));
          set_has_z();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void CMsgVector::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional float x = 1;
  if (has_x()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(1, this->x(), output);
  }

  // optional float y = 2;
  if (has_y()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(2, this->y(), output);
  }

  // optional float z = 3;
  if (has_z()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(3, this->z(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* CMsgVector::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional float x = 1;
  if (has_x()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(1, this->x(), target);
  }

  // optional float y = 2;
  if (has_y()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(2, this->y(), target);
  }

  // optional float z = 3;
  if (has_z()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(3, this->z(), target);
  }

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

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional float x = 1;
    if (has_x()) {
      total_size += 1 + 4;
    }

    // optional float y = 2;
    if (has_y()) {
      total_size += 1 + 4;
    }

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

void CMsgVector::MergeFrom(const CMsgVector& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_x()) {
      set_x(from.x());
    }
    if (from.has_y()) {
      set_y(from.y());
    }
    if (from.has_z()) {
      set_z(from.z());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

bool CMsgVector::IsInitialized() const {

  return true;
}

void CMsgVector::Swap(CMsgVector* other) {
  if (other != this) {
    std::swap(x_, other->x_);
    std::swap(y_, other->y_);
    std::swap(z_, other->z_);
    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 CMsgVector::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CMsgVector_descriptor_;
  metadata.reflection = CMsgVector_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int CMsgVector2D::kXFieldNumber;
const int CMsgVector2D::kYFieldNumber;
#endif  // !_MSC_VER

CMsgVector2D::CMsgVector2D()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void CMsgVector2D::InitAsDefaultInstance() {
}

CMsgVector2D::CMsgVector2D(const CMsgVector2D& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void CMsgVector2D::SharedCtor() {
  _cached_size_ = 0;
  x_ = 0;
  y_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CMsgVector2D::~CMsgVector2D() {
  SharedDtor();
}

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

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

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

CMsgVector2D* CMsgVector2D::default_instance_ = NULL;

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

void CMsgVector2D::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    x_ = 0;
    y_ = 0;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool CMsgVector2D::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional float x = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &x_)));
          set_has_x();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(21)) goto parse_y;
        break;
      }

      // optional float y = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
         parse_y:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &y_)));
          set_has_y();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void CMsgVector2D::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional float x = 1;
  if (has_x()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(1, this->x(), output);
  }

  // optional float y = 2;
  if (has_y()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(2, this->y(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* CMsgVector2D::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional float x = 1;
  if (has_x()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(1, this->x(), target);
  }

  // optional float y = 2;
  if (has_y()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(2, this->y(), target);
  }

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

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional float x = 1;
    if (has_x()) {
      total_size += 1 + 4;
    }

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

void CMsgVector2D::MergeFrom(const CMsgVector2D& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_x()) {
      set_x(from.x());
    }
    if (from.has_y()) {
      set_y(from.y());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

bool CMsgVector2D::IsInitialized() const {

  return true;
}

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


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

#ifndef _MSC_VER
const int CMsgQAngle::kXFieldNumber;
const int CMsgQAngle::kYFieldNumber;
const int CMsgQAngle::kZFieldNumber;
#endif  // !_MSC_VER

CMsgQAngle::CMsgQAngle()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void CMsgQAngle::InitAsDefaultInstance() {
}

CMsgQAngle::CMsgQAngle(const CMsgQAngle& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void CMsgQAngle::SharedCtor() {
  _cached_size_ = 0;
  x_ = 0;
  y_ = 0;
  z_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CMsgQAngle::~CMsgQAngle() {
  SharedDtor();
}

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

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

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

CMsgQAngle* CMsgQAngle::default_instance_ = NULL;

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

void CMsgQAngle::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    x_ = 0;
    y_ = 0;
    z_ = 0;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool CMsgQAngle::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional float x = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &x_)));
          set_has_x();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(21)) goto parse_y;
        break;
      }

      // optional float y = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
         parse_y:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &y_)));
          set_has_y();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(29)) goto parse_z;
        break;
      }

      // optional float z = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
         parse_z:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &z_)));
          set_has_z();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void CMsgQAngle::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional float x = 1;
  if (has_x()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(1, this->x(), output);
  }

  // optional float y = 2;
  if (has_y()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(2, this->y(), output);
  }

  // optional float z = 3;
  if (has_z()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(3, this->z(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* CMsgQAngle::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional float x = 1;
  if (has_x()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(1, this->x(), target);
  }

  // optional float y = 2;
  if (has_y()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(2, this->y(), target);
  }

  // optional float z = 3;
  if (has_z()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(3, this->z(), target);
  }

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

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional float x = 1;
    if (has_x()) {
      total_size += 1 + 4;
    }

    // optional float y = 2;
    if (has_y()) {
      total_size += 1 + 4;
    }

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

void CMsgQAngle::MergeFrom(const CMsgQAngle& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_x()) {
      set_x(from.x());
    }
    if (from.has_y()) {
      set_y(from.y());
    }
    if (from.has_z()) {
      set_z(from.z());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

bool CMsgQAngle::IsInitialized() const {

  return true;
}

void CMsgQAngle::Swap(CMsgQAngle* other) {
  if (other != this) {
    std::swap(x_, other->x_);
    std::swap(y_, other->y_);
    std::swap(z_, other->z_);
    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 CMsgQAngle::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CMsgQAngle_descriptor_;
  metadata.reflection = CMsgQAngle_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int CMsgRGBA::kRFieldNumber;
const int CMsgRGBA::kGFieldNumber;
const int CMsgRGBA::kBFieldNumber;
const int CMsgRGBA::kAFieldNumber;
#endif  // !_MSC_VER

CMsgRGBA::CMsgRGBA()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void CMsgRGBA::InitAsDefaultInstance() {
}

CMsgRGBA::CMsgRGBA(const CMsgRGBA& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void CMsgRGBA::SharedCtor() {
  _cached_size_ = 0;
  r_ = 0;
  g_ = 0;
  b_ = 0;
  a_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CMsgRGBA::~CMsgRGBA() {
  SharedDtor();
}

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

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

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

CMsgRGBA* CMsgRGBA::default_instance_ = NULL;

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

void CMsgRGBA::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    r_ = 0;
    g_ = 0;
    b_ = 0;
    a_ = 0;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool CMsgRGBA::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 r = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &r_)));
          set_has_r();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(16)) goto parse_g;
        break;
      }

      // optional int32 g = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_g:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &g_)));
          set_has_g();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(24)) goto parse_b;
        break;
      }

      // optional int32 b = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_b:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &b_)));
          set_has_b();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(32)) goto parse_a;
        break;
      }

      // optional int32 a = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_a:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &a_)));
          set_has_a();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void CMsgRGBA::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional int32 r = 1;
  if (has_r()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->r(), output);
  }

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

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

  // optional int32 a = 4;
  if (has_a()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->a(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* CMsgRGBA::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional int32 r = 1;
  if (has_r()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->r(), target);
  }

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

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

  // optional int32 a = 4;
  if (has_a()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(4, this->a(), target);
  }

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

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

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

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

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

    // optional int32 a = 4;
    if (has_a()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->a());
    }

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

void CMsgRGBA::MergeFrom(const CMsgRGBA& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_r()) {
      set_r(from.r());
    }
    if (from.has_g()) {
      set_g(from.g());
    }
    if (from.has_b()) {
      set_b(from.b());
    }
    if (from.has_a()) {
      set_a(from.a());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

bool CMsgRGBA::IsInitialized() const {

  return true;
}

void CMsgRGBA::Swap(CMsgRGBA* other) {
  if (other != this) {
    std::swap(r_, other->r_);
    std::swap(g_, other->g_);
    std::swap(b_, other->b_);
    std::swap(a_, other->a_);
    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 CMsgRGBA::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CMsgRGBA_descriptor_;
  metadata.reflection = CMsgRGBA_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int CNETMsg_Tick::kTickFieldNumber;
const int CNETMsg_Tick::kHostComputationtimeFieldNumber;
const int CNETMsg_Tick::kHostComputationtimeStdDeviationFieldNumber;
const int CNETMsg_Tick::kHostFramestarttimeStdDeviationFieldNumber;
const int CNETMsg_Tick::kHltvReplayFlagsFieldNumber;
#endif  // !_MSC_VER

CNETMsg_Tick::CNETMsg_Tick()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void CNETMsg_Tick::InitAsDefaultInstance() {
}

CNETMsg_Tick::CNETMsg_Tick(const CNETMsg_Tick& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void CNETMsg_Tick::SharedCtor() {
  _cached_size_ = 0;
  tick_ = 0u;
  host_computationtime_ = 0u;
  host_computationtime_std_deviation_ = 0u;
  host_framestarttime_std_deviation_ = 0u;
  hltv_replay_flags_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CNETMsg_Tick::~CNETMsg_Tick() {
  SharedDtor();
}

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

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

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

CNETMsg_Tick* CNETMsg_Tick::default_instance_ = NULL;

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

void CNETMsg_Tick::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    tick_ = 0u;
    host_computationtime_ = 0u;
    host_computationtime_std_deviation_ = 0u;
    host_framestarttime_std_deviation_ = 0u;
    hltv_replay_flags_ = 0u;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool CNETMsg_Tick::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional uint32 tick = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &tick_)));
          set_has_tick();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(32)) goto parse_host_computationtime;
        break;
      }

      // optional uint32 host_computationtime = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_host_computationtime:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &host_computationtime_)));
          set_has_host_computationtime();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(40)) goto parse_host_computationtime_std_deviation;
        break;
      }

      // optional uint32 host_computationtime_std_deviation = 5;
      case 5: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_host_computationtime_std_deviation:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &host_computationtime_std_deviation_)));
          set_has_host_computationtime_std_deviation();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(48)) goto parse_host_framestarttime_std_deviation;
        break;
      }

      // optional uint32 host_framestarttime_std_deviation = 6;
      case 6: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_host_framestarttime_std_deviation:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &host_framestarttime_std_deviation_)));
          set_has_host_framestarttime_std_deviation();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(56)) goto parse_hltv_replay_flags;
        break;
      }

      // optional uint32 hltv_replay_flags = 7;
      case 7: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_hltv_replay_flags:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &hltv_replay_flags_)));
          set_has_hltv_replay_flags();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void CNETMsg_Tick::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional uint32 tick = 1;
  if (has_tick()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->tick(), output);
  }

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

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

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

  // optional uint32 hltv_replay_flags = 7;
  if (has_hltv_replay_flags()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(7, this->hltv_replay_flags(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* CNETMsg_Tick::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional uint32 tick = 1;
  if (has_tick()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->tick(), target);
  }

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

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

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

  // optional uint32 hltv_replay_flags = 7;
  if (has_hltv_replay_flags()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(7, this->hltv_replay_flags(), target);
  }

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

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

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

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

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

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

    // optional uint32 hltv_replay_flags = 7;
    if (has_hltv_replay_flags()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->hltv_replay_flags());
    }

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

void CNETMsg_Tick::MergeFrom(const CNETMsg_Tick& 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_host_computationtime()) {
      set_host_computationtime(from.host_computationtime());
    }
    if (from.has_host_computationtime_std_deviation()) {
      set_host_computationtime_std_deviation(from.host_computationtime_std_deviation());
    }
    if (from.has_host_framestarttime_std_deviation()) {
      set_host_framestarttime_std_deviation(from.host_framestarttime_std_deviation());
    }
    if (from.has_hltv_replay_flags()) {
      set_hltv_replay_flags(from.hltv_replay_flags());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

bool CNETMsg_Tick::IsInitialized() const {

  return true;
}

void CNETMsg_Tick::Swap(CNETMsg_Tick* other) {
  if (other != this) {
    std::swap(tick_, other->tick_);
    std::swap(host_computationtime_, other->host_computationtime_);
    std::swap(host_computationtime_std_deviation_, other->host_computationtime_std_deviation_);
    std::swap(host_framestarttime_std_deviation_, other->host_framestarttime_std_deviation_);
    std::swap(hltv_replay_flags_, other->hltv_replay_flags_);
    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 CNETMsg_Tick::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CNETMsg_Tick_descriptor_;
  metadata.reflection = CNETMsg_Tick_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int CNETMsg_StringCmd::kCommandFieldNumber;
#endif  // !_MSC_VER

CNETMsg_StringCmd::CNETMsg_StringCmd()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void CNETMsg_StringCmd::InitAsDefaultInstance() {
}

CNETMsg_StringCmd::CNETMsg_StringCmd(const CNETMsg_StringCmd& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void CNETMsg_StringCmd::SharedCtor() {
  _cached_size_ = 0;
  command_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CNETMsg_StringCmd::~CNETMsg_StringCmd() {
  SharedDtor();
}

void CNETMsg_StringCmd::SharedDtor() {
  if (command_ != &::google::protobuf::internal::kEmptyString) {
    delete command_;
  }
  if (this != default_instance_) {
  }
}

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

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

CNETMsg_StringCmd* CNETMsg_StringCmd::default_instance_ = NULL;

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

void CNETMsg_StringCmd::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_command()) {
      if (command_ != &::google::protobuf::internal::kEmptyString) {
        command_->clear();
      }
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool CNETMsg_StringCmd::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional string command = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_command()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->command().data(), this->command().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void CNETMsg_StringCmd::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional string command = 1;
  if (has_command()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->command().data(), this->command().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      1, this->command(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* CNETMsg_StringCmd::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional string command = 1;
  if (has_command()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->command().data(), this->command().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        1, this->command(), target);
  }

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

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

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

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

void CNETMsg_StringCmd::MergeFrom(const CNETMsg_StringCmd& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_command()) {
      set_command(from.command());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

bool CNETMsg_StringCmd::IsInitialized() const {

  return true;
}

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


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

#ifndef _MSC_VER
const int CNETMsg_SignonState::kSignonStateFieldNumber;
const int CNETMsg_SignonState::kSpawnCountFieldNumber;
const int CNETMsg_SignonState::kNumServerPlayersFieldNumber;
const int CNETMsg_SignonState::kPlayersNetworkidsFieldNumber;
const int CNETMsg_SignonState::kMapNameFieldNumber;
#endif  // !_MSC_VER

CNETMsg_SignonState::CNETMsg_SignonState()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void CNETMsg_SignonState::InitAsDefaultInstance() {
}

CNETMsg_SignonState::CNETMsg_SignonState(const CNETMsg_SignonState& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void CNETMsg_SignonState::SharedCtor() {
  _cached_size_ = 0;
  signon_state_ = 0u;
  spawn_count_ = 0u;
  num_server_players_ = 0u;
  map_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CNETMsg_SignonState::~CNETMsg_SignonState() {
  SharedDtor();
}

void CNETMsg_SignonState::SharedDtor() {
  if (map_name_ != &::google::protobuf::internal::kEmptyString) {
    delete map_name_;
  }
  if (this != default_instance_) {
  }
}

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

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

CNETMsg_SignonState* CNETMsg_SignonState::default_instance_ = NULL;

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

void CNETMsg_SignonState::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    signon_state_ = 0u;
    spawn_count_ = 0u;
    num_server_players_ = 0u;
    if (has_map_name()) {
      if (map_name_ != &::google::protobuf::internal::kEmptyString) {
        map_name_->clear();
      }
    }
  }
  players_networkids_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool CNETMsg_SignonState::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional uint32 signon_state = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &signon_state_)));
          set_has_signon_state();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(16)) goto parse_spawn_count;
        break;
      }

      // optional uint32 spawn_count = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_spawn_count:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &spawn_count_)));
          set_has_spawn_count();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(24)) goto parse_num_server_players;
        break;
      }

      // optional uint32 num_server_players = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_num_server_players:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &num_server_players_)));
          set_has_num_server_players();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(34)) goto parse_players_networkids;
        break;
      }

      // repeated string players_networkids = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_players_networkids:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->add_players_networkids()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->players_networkids(this->players_networkids_size() - 1).data(),
            this->players_networkids(this->players_networkids_size() - 1).length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(34)) goto parse_players_networkids;
        if (input->ExpectTag(42)) goto parse_map_name;
        break;
      }

      // optional string map_name = 5;
      case 5: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_map_name:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_map_name()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->map_name().data(), this->map_name().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void CNETMsg_SignonState::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional uint32 signon_state = 1;
  if (has_signon_state()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->signon_state(), output);
  }

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

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

  // repeated string players_networkids = 4;
  for (int i = 0; i < this->players_networkids_size(); i++) {
  ::google::protobuf::internal::WireFormat::VerifyUTF8String(
    this->players_networkids(i).data(), this->players_networkids(i).length(),
    ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      4, this->players_networkids(i), output);
  }

  // optional string map_name = 5;
  if (has_map_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->map_name().data(), this->map_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      5, this->map_name(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* CNETMsg_SignonState::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional uint32 signon_state = 1;
  if (has_signon_state()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->signon_state(), target);
  }

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

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

  // repeated string players_networkids = 4;
  for (int i = 0; i < this->players_networkids_size(); i++) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->players_networkids(i).data(), this->players_networkids(i).length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target = ::google::protobuf::internal::WireFormatLite::
      WriteStringToArray(4, this->players_networkids(i), target);
  }

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

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

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

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

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

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

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

  }
  // repeated string players_networkids = 4;
  total_size += 1 * this->players_networkids_size();
  for (int i = 0; i < this->players_networkids_size(); i++) {
    total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
      this->players_networkids(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 CNETMsg_SignonState::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const CNETMsg_SignonState* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const CNETMsg_SignonState*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void CNETMsg_SignonState::MergeFrom(const CNETMsg_SignonState& from) {
  GOOGLE_CHECK_NE(&from, this);
  players_networkids_.MergeFrom(from.players_networkids_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_signon_state()) {
      set_signon_state(from.signon_state());
    }
    if (from.has_spawn_count()) {
      set_spawn_count(from.spawn_count());
    }
    if (from.has_num_server_players()) {
      set_num_server_players(from.num_server_players());
    }
    if (from.has_map_name()) {
      set_map_name(from.map_name());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

bool CNETMsg_SignonState::IsInitialized() const {

  return true;
}

void CNETMsg_SignonState::Swap(CNETMsg_SignonState* other) {
  if (other != this) {
    std::swap(signon_state_, other->signon_state_);
    std::swap(spawn_count_, other->spawn_count_);
    std::swap(num_server_players_, other->num_server_players_);
    players_networkids_.Swap(&other->players_networkids_);
    std::swap(map_name_, other->map_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 CNETMsg_SignonState::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CNETMsg_SignonState_descriptor_;
  metadata.reflection = CNETMsg_SignonState_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int CMsg_CVars_CVar::kNameFieldNumber;
const int CMsg_CVars_CVar::kValueFieldNumber;
const int CMsg_CVars_CVar::kDictionaryNameFieldNumber;
#endif  // !_MSC_VER

CMsg_CVars_CVar::CMsg_CVars_CVar()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void CMsg_CVars_CVar::InitAsDefaultInstance() {
}

CMsg_CVars_CVar::CMsg_CVars_CVar(const CMsg_CVars_CVar& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void CMsg_CVars_CVar::SharedCtor() {
  _cached_size_ = 0;
  name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  value_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  dictionary_name_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CMsg_CVars_CVar::~CMsg_CVars_CVar() {
  SharedDtor();
}

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

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

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

CMsg_CVars_CVar* CMsg_CVars_CVar::default_instance_ = NULL;

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

void CMsg_CVars_CVar::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_name()) {
      if (name_ != &::google::protobuf::internal::kEmptyString) {
        name_->clear();
      }
    }
    if (has_value()) {
      if (value_ != &::google::protobuf::internal::kEmptyString) {
        value_->clear();
      }
    }
    dictionary_name_ = 0u;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool CMsg_CVars_CVar::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional string name = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_name()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->name().data(), this->name().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_value;
        break;
      }

      // optional string value = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_value:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_value()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->value().data(), this->value().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(24)) goto parse_dictionary_name;
        break;
      }

      // optional uint32 dictionary_name = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_dictionary_name:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &dictionary_name_)));
          set_has_dictionary_name();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void CMsg_CVars_CVar::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional string name = 1;
  if (has_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->name().data(), this->name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      1, this->name(), output);
  }

  // optional string value = 2;
  if (has_value()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->value().data(), this->value().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      2, this->value(), output);
  }

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

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* CMsg_CVars_CVar::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional string name = 1;
  if (has_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->name().data(), this->name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        1, this->name(), target);
  }

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

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

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

int CMsg_CVars_CVar::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 string value = 2;
    if (has_value()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->value());
    }

    // optional uint32 dictionary_name = 3;
    if (has_dictionary_name()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->dictionary_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 CMsg_CVars_CVar::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const CMsg_CVars_CVar* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const CMsg_CVars_CVar*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void CMsg_CVars_CVar::MergeFrom(const CMsg_CVars_CVar& 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_value()) {
      set_value(from.value());
    }
    if (from.has_dictionary_name()) {
      set_dictionary_name(from.dictionary_name());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

bool CMsg_CVars_CVar::IsInitialized() const {

  return true;
}

void CMsg_CVars_CVar::Swap(CMsg_CVars_CVar* other) {
  if (other != this) {
    std::swap(name_, other->name_);
    std::swap(value_, other->value_);
    std::swap(dictionary_name_, other->dictionary_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 CMsg_CVars_CVar::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CMsg_CVars_CVar_descriptor_;
  metadata.reflection = CMsg_CVars_CVar_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int CMsg_CVars::kCvarsFieldNumber;
#endif  // !_MSC_VER

CMsg_CVars::CMsg_CVars()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void CMsg_CVars::InitAsDefaultInstance() {
}

CMsg_CVars::CMsg_CVars(const CMsg_CVars& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

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

CMsg_CVars::~CMsg_CVars() {
  SharedDtor();
}

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

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

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

CMsg_CVars* CMsg_CVars::default_instance_ = NULL;

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

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

bool CMsg_CVars::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // repeated .CMsg_CVars.CVar cvars = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_cvars:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_cvars()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(10)) goto parse_cvars;
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void CMsg_CVars::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // repeated .CMsg_CVars.CVar cvars = 1;
  for (int i = 0; i < this->cvars_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->cvars(i), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* CMsg_CVars::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // repeated .CMsg_CVars.CVar cvars = 1;
  for (int i = 0; i < this->cvars_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->cvars(i), target);
  }

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

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

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

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

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

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

bool CMsg_CVars::IsInitialized() const {

  return true;
}

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


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

#ifndef _MSC_VER
const int CNETMsg_SetConVar::kConvarsFieldNumber;
#endif  // !_MSC_VER

CNETMsg_SetConVar::CNETMsg_SetConVar()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void CNETMsg_SetConVar::InitAsDefaultInstance() {
  convars_ = const_cast< ::CMsg_CVars*>(&::CMsg_CVars::default_instance());
}

CNETMsg_SetConVar::CNETMsg_SetConVar(const CNETMsg_SetConVar& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void CNETMsg_SetConVar::SharedCtor() {
  _cached_size_ = 0;
  convars_ = NULL;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CNETMsg_SetConVar::~CNETMsg_SetConVar() {
  SharedDtor();
}

void CNETMsg_SetConVar::SharedDtor() {
  if (this != default_instance_) {
    delete convars_;
  }
}

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

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

CNETMsg_SetConVar* CNETMsg_SetConVar::default_instance_ = NULL;

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

void CNETMsg_SetConVar::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_convars()) {
      if (convars_ != NULL) convars_->::CMsg_CVars::Clear();
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool CNETMsg_SetConVar::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .CMsg_CVars convars = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_convars()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void CNETMsg_SetConVar::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional .CMsg_CVars convars = 1;
  if (has_convars()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->convars(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* CNETMsg_SetConVar::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional .CMsg_CVars convars = 1;
  if (has_convars()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->convars(), target);
  }

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

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

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

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

void CNETMsg_SetConVar::MergeFrom(const CNETMsg_SetConVar& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_convars()) {
      mutable_convars()->::CMsg_CVars::MergeFrom(from.convars());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

bool CNETMsg_SetConVar::IsInitialized() const {

  return true;
}

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


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

#ifndef _MSC_VER
#endif  // !_MSC_VER

CNETMsg_NOP::CNETMsg_NOP()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void CNETMsg_NOP::InitAsDefaultInstance() {
}

CNETMsg_NOP::CNETMsg_NOP(const CNETMsg_NOP& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

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

CNETMsg_NOP::~CNETMsg_NOP() {
  SharedDtor();
}

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

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

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

CNETMsg_NOP* CNETMsg_NOP::default_instance_ = NULL;

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

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

bool CNETMsg_NOP::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
        ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
      return true;
    }
    DO_(::google::protobuf::internal::WireFormat::SkipField(
          input, tag, mutable_unknown_fields()));
  }
  return true;
#undef DO_
}

void CNETMsg_NOP::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* CNETMsg_NOP::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

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

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

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

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

bool CNETMsg_NOP::IsInitialized() const {

  return true;
}

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

::google::protobuf::Metadata CNETMsg_NOP::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CNETMsg_NOP_descriptor_;
  metadata.reflection = CNETMsg_NOP_reflection_;
  return metadata;
}


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

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

CNETMsg_Disconnect::CNETMsg_Disconnect()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void CNETMsg_Disconnect::InitAsDefaultInstance() {
}

CNETMsg_Disconnect::CNETMsg_Disconnect(const CNETMsg_Disconnect& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

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

CNETMsg_Disconnect::~CNETMsg_Disconnect() {
  SharedDtor();
}

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

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

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

CNETMsg_Disconnect* CNETMsg_Disconnect::default_instance_ = NULL;

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

void CNETMsg_Disconnect::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_text()) {
      if (text_ != &::google::protobuf::internal::kEmptyString) {
        text_->clear();
      }
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool CNETMsg_Disconnect::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional string text = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_text()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->text().data(), this->text().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void CNETMsg_Disconnect::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional string text = 1;
  if (has_text()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->text().data(), this->text().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      1, this->text(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

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

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

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

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

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

bool CNETMsg_Disconnect::IsInitialized() const {

  return true;
}

void CNETMsg_Disconnect::Swap(CNETMsg_Disconnect* 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 CNETMsg_Disconnect::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CNETMsg_Disconnect_descriptor_;
  metadata.reflection = CNETMsg_Disconnect_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int CNETMsg_File::kTransferIdFieldNumber;
const int CNETMsg_File::kFileNameFieldNumber;
const int CNETMsg_File::kIsReplayDemoFileFieldNumber;
const int CNETMsg_File::kDenyFieldNumber;
#endif  // !_MSC_VER

CNETMsg_File::CNETMsg_File()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void CNETMsg_File::InitAsDefaultInstance() {
}

CNETMsg_File::CNETMsg_File(const CNETMsg_File& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void CNETMsg_File::SharedCtor() {
  _cached_size_ = 0;
  transfer_id_ = 0;
  file_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  is_replay_demo_file_ = false;
  deny_ = false;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CNETMsg_File::~CNETMsg_File() {
  SharedDtor();
}

void CNETMsg_File::SharedDtor() {
  if (file_name_ != &::google::protobuf::internal::kEmptyString) {
    delete file_name_;
  }
  if (this != default_instance_) {
  }
}

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

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

CNETMsg_File* CNETMsg_File::default_instance_ = NULL;

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

void CNETMsg_File::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    transfer_id_ = 0;
    if (has_file_name()) {
      if (file_name_ != &::google::protobuf::internal::kEmptyString) {
        file_name_->clear();
      }
    }
    is_replay_demo_file_ = false;
    deny_ = false;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool CNETMsg_File::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 transfer_id = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &transfer_id_)));
          set_has_transfer_id();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_file_name;
        break;
      }

      // optional string file_name = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_file_name:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_file_name()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->file_name().data(), this->file_name().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(24)) goto parse_is_replay_demo_file;
        break;
      }

      // optional bool is_replay_demo_file = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_is_replay_demo_file:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &is_replay_demo_file_)));
          set_has_is_replay_demo_file();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(32)) goto parse_deny;
        break;
      }

      // optional bool deny = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_deny:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &deny_)));
          set_has_deny();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void CNETMsg_File::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional int32 transfer_id = 1;
  if (has_transfer_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->transfer_id(), output);
  }

  // optional string file_name = 2;
  if (has_file_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->file_name().data(), this->file_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      2, this->file_name(), output);
  }

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

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

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* CNETMsg_File::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional int32 transfer_id = 1;
  if (has_transfer_id()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->transfer_id(), target);
  }

  // optional string file_name = 2;
  if (has_file_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->file_name().data(), this->file_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        2, this->file_name(), target);
  }

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

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

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

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

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

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

    // optional bool is_replay_demo_file = 3;
    if (has_is_replay_demo_file()) {
      total_size += 1 + 1;
    }

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

void CNETMsg_File::MergeFrom(const CNETMsg_File& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_transfer_id()) {
      set_transfer_id(from.transfer_id());
    }
    if (from.has_file_name()) {
      set_file_name(from.file_name());
    }
    if (from.has_is_replay_demo_file()) {
      set_is_replay_demo_file(from.is_replay_demo_file());
    }
    if (from.has_deny()) {
      set_deny(from.deny());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

bool CNETMsg_File::IsInitialized() const {

  return true;
}

void CNETMsg_File::Swap(CNETMsg_File* other) {
  if (other != this) {
    std::swap(transfer_id_, other->transfer_id_);
    std::swap(file_name_, other->file_name_);
    std::swap(is_replay_demo_file_, other->is_replay_demo_file_);
    std::swap(deny_, other->deny_);
    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 CNETMsg_File::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CNETMsg_File_descriptor_;
  metadata.reflection = CNETMsg_File_reflection_;
  return metadata;
}


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

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

CNETMsg_SplitScreenUser::CNETMsg_SplitScreenUser()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void CNETMsg_SplitScreenUser::InitAsDefaultInstance() {
}

CNETMsg_SplitScreenUser::CNETMsg_SplitScreenUser(const CNETMsg_SplitScreenUser& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

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

CNETMsg_SplitScreenUser::~CNETMsg_SplitScreenUser() {
  SharedDtor();
}

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

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

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

CNETMsg_SplitScreenUser* CNETMsg_SplitScreenUser::default_instance_ = NULL;

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

void CNETMsg_SplitScreenUser::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    slot_ = 0;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool CNETMsg_SplitScreenUser::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 slot = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &slot_)));
          set_has_slot();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void CNETMsg_SplitScreenUser::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // 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);
  }
}

::google::protobuf::uint8* CNETMsg_SplitScreenUser::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // 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);
  }
  return target;
}

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

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

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

bool CNETMsg_SplitScreenUser::IsInitialized() const {

  return true;
}

void CNETMsg_SplitScreenUser::Swap(CNETMsg_SplitScreenUser* 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 CNETMsg_SplitScreenUser::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CNETMsg_SplitScreenUser_descriptor_;
  metadata.reflection = CNETMsg_SplitScreenUser_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int CNETMsg_PlayerAvatarData::kAccountidFieldNumber;
const int CNETMsg_PlayerAvatarData::kRgbFieldNumber;
#endif  // !_MSC_VER

CNETMsg_PlayerAvatarData::CNETMsg_PlayerAvatarData()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void CNETMsg_PlayerAvatarData::InitAsDefaultInstance() {
}

CNETMsg_PlayerAvatarData::CNETMsg_PlayerAvatarData(const CNETMsg_PlayerAvatarData& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void CNETMsg_PlayerAvatarData::SharedCtor() {
  _cached_size_ = 0;
  accountid_ = 0u;
  rgb_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CNETMsg_PlayerAvatarData::~CNETMsg_PlayerAvatarData() {
  SharedDtor();
}

void CNETMsg_PlayerAvatarData::SharedDtor() {
  if (rgb_ != &::google::protobuf::internal::kEmptyString) {
    delete rgb_;
  }
  if (this != default_instance_) {
  }
}

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

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

CNETMsg_PlayerAvatarData* CNETMsg_PlayerAvatarData::default_instance_ = NULL;

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

void CNETMsg_PlayerAvatarData::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    accountid_ = 0u;
    if (has_rgb()) {
      if (rgb_ != &::google::protobuf::internal::kEmptyString) {
        rgb_->clear();
      }
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool CNETMsg_PlayerAvatarData::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional uint32 accountid = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &accountid_)));
          set_has_accountid();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_rgb;
        break;
      }

      // optional bytes rgb = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_rgb:
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_rgb()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void CNETMsg_PlayerAvatarData::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional uint32 accountid = 1;
  if (has_accountid()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->accountid(), output);
  }

  // optional bytes rgb = 2;
  if (has_rgb()) {
    ::google::protobuf::internal::WireFormatLite::WriteBytes(
      2, this->rgb(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* CNETMsg_PlayerAvatarData::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional uint32 accountid = 1;
  if (has_accountid()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->accountid(), target);
  }

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

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

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

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

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

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

void CNETMsg_PlayerAvatarData::MergeFrom(const CNETMsg_PlayerAvatarData& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_accountid()) {
      set_accountid(from.accountid());
    }
    if (from.has_rgb()) {
      set_rgb(from.rgb());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

bool CNETMsg_PlayerAvatarData::IsInitialized() const {

  return true;
}

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


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

#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();
}

void CCLCMsg_ClientInfo::InitAsDefaultInstance() {
}

CCLCMsg_ClientInfo::CCLCMsg_ClientInfo(const CCLCMsg_ClientInfo& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void CCLCMsg_ClientInfo::SharedCtor() {
  _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::kEmptyString);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CCLCMsg_ClientInfo::~CCLCMsg_ClientInfo() {
  SharedDtor();
}

void CCLCMsg_ClientInfo::SharedDtor() {
  if (friends_name_ != &::google::protobuf::internal::kEmptyString) {
    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() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    send_table_crc_ = 0u;
    server_count_ = 0u;
    is_hltv_ = false;
    is_replay_ = false;
    friends_id_ = 0u;
    if (has_friends_name()) {
      if (friends_name_ != &::google::protobuf::internal::kEmptyString) {
        friends_name_->clear();
      }
    }
  }
  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)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional fixed32 send_table_crc = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
                 input, &send_table_crc_)));
          set_has_send_table_crc();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(16)) goto parse_server_count;
        break;
      }

      // optional uint32 server_count = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         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_uninterpreted;
        }
        if (input->ExpectTag(24)) goto parse_is_hltv;
        break;
      }

      // optional bool is_hltv = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         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_uninterpreted;
        }
        if (input->ExpectTag(32)) goto parse_is_replay;
        break;
      }

      // optional bool is_replay = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         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_uninterpreted;
        }
        if (input->ExpectTag(40)) goto parse_friends_id;
        break;
      }

      // optional uint32 friends_id = 5;
      case 5: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         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_uninterpreted;
        }
        if (input->ExpectTag(50)) goto parse_friends_name;
        break;
      }

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

      // repeated fixed32 custom_files = 7;
      case 7: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
         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 (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag)
                   == ::google::protobuf::internal::WireFormatLite::
                      WIRETYPE_LENGTH_DELIMITED) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
                 input, this->mutable_custom_files())));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(61)) goto parse_custom_files;
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void CCLCMsg_ClientInfo::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // 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::VerifyUTF8String(
      this->friends_name().data(), this->friends_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      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);
  }
}

::google::protobuf::uint8* CCLCMsg_ClientInfo::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // 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::VerifyUTF8String(
      this->friends_name().data(), this->friends_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    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);
  }
  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();
}

void CCLCMsg_Move::InitAsDefaultInstance() {
}

CCLCMsg_Move::CCLCMsg_Move(const CCLCMsg_Move& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

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

CCLCMsg_Move::~CCLCMsg_Move() {
  SharedDtor();
}

void CCLCMsg_Move::SharedDtor() {
  if (data_ != &::google::protobuf::internal::kEmptyString) {
    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() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    num_backup_commands_ = 0u;
    num_new_commands_ = 0u;
    if (has_data()) {
      if (data_ != &::google::protobuf::internal::kEmptyString) {
        data_->clear();
      }
    }
  }
  ::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)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional uint32 num_backup_commands = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &num_backup_commands_)));
          set_has_num_backup_commands();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(16)) goto parse_num_new_commands;
        break;
      }

      // optional uint32 num_new_commands = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         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_uninterpreted;
        }
        if (input->ExpectTag(26)) goto parse_data;
        break;
      }

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

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void CCLCMsg_Move::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // 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::WriteBytes(
      3, this->data(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* CCLCMsg_Move::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // 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);
  }
  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 CCLCMsg_VoiceData::kDataFieldNumber;
const int CCLCMsg_VoiceData::kXuidFieldNumber;
const int CCLCMsg_VoiceData::kFormatFieldNumber;
const int CCLCMsg_VoiceData::kSequenceBytesFieldNumber;
const int CCLCMsg_VoiceData::kSectionNumberFieldNumber;
const int CCLCMsg_VoiceData::kUncompressedSampleOffsetFieldNumber;
#endif  // !_MSC_VER

CCLCMsg_VoiceData::CCLCMsg_VoiceData()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void CCLCMsg_VoiceData::InitAsDefaultInstance() {
}

CCLCMsg_VoiceData::CCLCMsg_VoiceData(const CCLCMsg_VoiceData& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void CCLCMsg_VoiceData::SharedCtor() {
  _cached_size_ = 0;
  data_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  xuid_ = GOOGLE_ULONGLONG(0);
  format_ = 1;
  sequence_bytes_ = 0;
  section_number_ = 0u;
  uncompressed_sample_offset_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CCLCMsg_VoiceData::~CCLCMsg_VoiceData() {
  SharedDtor();
}

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

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() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_data()) {
      if (data_ != &::google::protobuf::internal::kEmptyString) {
        data_->clear();
      }
    }
    xuid_ = GOOGLE_ULONGLONG(0);
    format_ = 1;
    sequence_bytes_ = 0;
    section_number_ = 0u;
    uncompressed_sample_offset_ = 0u;
  }
  ::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)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional bytes data = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_data()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(17)) goto parse_xuid;
        break;
      }

      // optional fixed64 xuid = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
         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_uninterpreted;
        }
        if (input->ExpectTag(24)) goto parse_format;
        break;
      }

      // optional .VoiceDataFormat_t format = 3 [default = VOICEDATA_FORMAT_ENGINE];
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_format:
          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(3, value);
          }
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(32)) goto parse_sequence_bytes;
        break;
      }

      // optional int32 sequence_bytes = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         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_uninterpreted;
        }
        if (input->ExpectTag(40)) goto parse_section_number;
        break;
      }

      // optional uint32 section_number = 5;
      case 5: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         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_uninterpreted;
        }
        if (input->ExpectTag(48)) goto parse_uncompressed_sample_offset;
        break;
      }

      // optional uint32 uncompressed_sample_offset = 6;
      case 6: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         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_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

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

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

  // optional .VoiceDataFormat_t format = 3 [default = VOICEDATA_FORMAT_ENGINE];
  if (has_format()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      3, this->format(), output);
  }

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

  // optional uint32 section_number = 5;
  if (has_section_number()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(5, this->section_number(), 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);
  }
}

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

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

  // optional .VoiceDataFormat_t format = 3 [default = VOICEDATA_FORMAT_ENGINE];
  if (has_format()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      3, this->format(), target);
  }

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

  // optional uint32 section_number = 5;
  if (has_section_number()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(5, this->section_number(), 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);
  }
  return target;
}

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

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

    // optional .VoiceDataFormat_t format = 3 [default = VOICEDATA_FORMAT_ENGINE];
    if (has_format()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->format());
    }

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

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

    // 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 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_data()) {
      set_data(from.data());
    }
    if (from.has_xuid()) {
      set_xuid(from.xuid());
    }
    if (from.has_format()) {
      set_format(from.format());
    }
    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_uncompressed_sample_offset()) {
      set_uncompressed_sample_offset(from.uncompressed_sample_offset());
    }
  }
  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(data_, other->data_);
    std::swap(xuid_, other->xuid_);
    std::swap(format_, other->format_);
    std::swap(sequence_bytes_, other->sequence_bytes_);
    std::swap(section_number_, other->section_number_);
    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 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();
}

void CCLCMsg_BaselineAck::InitAsDefaultInstance() {
}

CCLCMsg_BaselineAck::CCLCMsg_BaselineAck(const CCLCMsg_BaselineAck& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

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

CCLCMsg_BaselineAck::~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() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    baseline_tick_ = 0;
    baseline_nr_ = 0;
  }
  ::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)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 baseline_tick = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &baseline_tick_)));
          set_has_baseline_tick();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(16)) goto parse_baseline_nr;
        break;
      }

      // optional int32 baseline_nr = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         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_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void CCLCMsg_BaselineAck::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // 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);
  }
}

::google::protobuf::uint8* CCLCMsg_BaselineAck::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // 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);
  }
  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();
}

void CCLCMsg_ListenEvents::InitAsDefaultInstance() {
}

CCLCMsg_ListenEvents::CCLCMsg_ListenEvents(const CCLCMsg_ListenEvents& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

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

CCLCMsg_ListenEvents::~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)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // repeated fixed32 event_mask = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
         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 (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag)
                   == ::google::protobuf::internal::WireFormatLite::
                      WIRETYPE_LENGTH_DELIMITED) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
                 input, this->mutable_event_mask())));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(13)) goto parse_event_mask;
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void CCLCMsg_ListenEvents::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // 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);
  }
}

::google::protobuf::uint8* CCLCMsg_ListenEvents::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // 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);
  }
  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();
}

void CCLCMsg_RespondCvarValue::InitAsDefaultInstance() {
}

CCLCMsg_RespondCvarValue::CCLCMsg_RespondCvarValue(const CCLCMsg_RespondCvarValue& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

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

CCLCMsg_RespondCvarValue::~CCLCMsg_RespondCvarValue() {
  SharedDtor();
}

void CCLCMsg_RespondCvarValue::SharedDtor() {
  if (name_ != &::google::protobuf::internal::kEmptyString) {
    delete name_;
  }
  if (value_ != &::google::protobuf::internal::kEmptyString) {
    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() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    cookie_ = 0;
    status_code_ = 0;
    if (has_name()) {
      if (name_ != &::google::protobuf::internal::kEmptyString) {
        name_->clear();
      }
    }
    if (has_value()) {
      if (value_ != &::google::protobuf::internal::kEmptyString) {
        value_->clear();
      }
    }
  }
  ::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)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 cookie = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &cookie_)));
          set_has_cookie();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(16)) goto parse_status_code;
        break;
      }

      // optional int32 status_code = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         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_uninterpreted;
        }
        if (input->ExpectTag(26)) goto parse_name;
        break;
      }

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

      // optional string value = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_value:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_value()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->value().data(), this->value().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void CCLCMsg_RespondCvarValue::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // 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::VerifyUTF8String(
      this->name().data(), this->name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      3, this->name(), output);
  }

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

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* CCLCMsg_RespondCvarValue::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // 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::VerifyUTF8String(
      this->name().data(), this->name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        3, this->name(), target);
  }

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

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  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::kFileFractionFieldNumber;
const int CCLCMsg_FileCRCCheck::kMd5FieldNumber;
const int CCLCMsg_FileCRCCheck::kCrcFieldNumber;
const int CCLCMsg_FileCRCCheck::kFileHashTypeFieldNumber;
const int CCLCMsg_FileCRCCheck::kFileLenFieldNumber;
const int CCLCMsg_FileCRCCheck::kPackFileIdFieldNumber;
const int CCLCMsg_FileCRCCheck::kPackFileNumberFieldNumber;
#endif  // !_MSC_VER

CCLCMsg_FileCRCCheck::CCLCMsg_FileCRCCheck()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void CCLCMsg_FileCRCCheck::InitAsDefaultInstance() {
}

CCLCMsg_FileCRCCheck::CCLCMsg_FileCRCCheck(const CCLCMsg_FileCRCCheck& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void CCLCMsg_FileCRCCheck::SharedCtor() {
  _cached_size_ = 0;
  code_path_ = 0;
  path_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  code_filename_ = 0;
  filename_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  file_fraction_ = 0;
  md5_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  crc_ = 0u;
  file_hash_type_ = 0;
  file_len_ = 0;
  pack_file_id_ = 0;
  pack_file_number_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CCLCMsg_FileCRCCheck::~CCLCMsg_FileCRCCheck() {
  SharedDtor();
}

void CCLCMsg_FileCRCCheck::SharedDtor() {
  if (path_ != &::google::protobuf::internal::kEmptyString) {
    delete path_;
  }
  if (filename_ != &::google::protobuf::internal::kEmptyString) {
    delete filename_;
  }
  if (md5_ != &::google::protobuf::internal::kEmptyString) {
    delete md5_;
  }
  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() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    code_path_ = 0;
    if (has_path()) {
      if (path_ != &::google::protobuf::internal::kEmptyString) {
        path_->clear();
      }
    }
    code_filename_ = 0;
    if (has_filename()) {
      if (filename_ != &::google::protobuf::internal::kEmptyString) {
        filename_->clear();
      }
    }
    file_fraction_ = 0;
    if (has_md5()) {
      if (md5_ != &::google::protobuf::internal::kEmptyString) {
        md5_->clear();
      }
    }
    crc_ = 0u;
    file_hash_type_ = 0;
  }
  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
    file_len_ = 0;
    pack_file_id_ = 0;
    pack_file_number_ = 0;
  }
  ::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)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 code_path = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &code_path_)));
          set_has_code_path();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_path;
        break;
      }

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

      // optional int32 code_filename = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         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_uninterpreted;
        }
        if (input->ExpectTag(34)) goto parse_filename;
        break;
      }

      // optional string filename = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_filename:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_filename()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->filename().data(), this->filename().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(40)) goto parse_file_fraction;
        break;
      }

      // optional int32 file_fraction = 5;
      case 5: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_file_fraction:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &file_fraction_)));
          set_has_file_fraction();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(50)) goto parse_md5;
        break;
      }

      // optional bytes md5 = 6;
      case 6: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_md5:
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_md5()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(56)) goto parse_crc;
        break;
      }

      // optional uint32 crc = 7;
      case 7: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_crc:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &crc_)));
          set_has_crc();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(64)) goto parse_file_hash_type;
        break;
      }

      // optional int32 file_hash_type = 8;
      case 8: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_file_hash_type:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &file_hash_type_)));
          set_has_file_hash_type();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(72)) goto parse_file_len;
        break;
      }

      // optional int32 file_len = 9;
      case 9: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_file_len:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &file_len_)));
          set_has_file_len();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(80)) goto parse_pack_file_id;
        break;
      }

      // optional int32 pack_file_id = 10;
      case 10: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_pack_file_id:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &pack_file_id_)));
          set_has_pack_file_id();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(88)) goto parse_pack_file_number;
        break;
      }

      // optional int32 pack_file_number = 11;
      case 11: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_pack_file_number:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &pack_file_number_)));
          set_has_pack_file_number();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void CCLCMsg_FileCRCCheck::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // 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::VerifyUTF8String(
      this->path().data(), this->path().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      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::VerifyUTF8String(
      this->filename().data(), this->filename().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      4, this->filename(), output);
  }

  // optional int32 file_fraction = 5;
  if (has_file_fraction()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(5, this->file_fraction(), output);
  }

  // optional bytes md5 = 6;
  if (has_md5()) {
    ::google::protobuf::internal::WireFormatLite::WriteBytes(
      6, this->md5(), output);
  }

  // optional uint32 crc = 7;
  if (has_crc()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(7, this->crc(), output);
  }

  // optional int32 file_hash_type = 8;
  if (has_file_hash_type()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(8, this->file_hash_type(), output);
  }

  // optional int32 file_len = 9;
  if (has_file_len()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(9, this->file_len(), output);
  }

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

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

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* CCLCMsg_FileCRCCheck::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // 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::VerifyUTF8String(
      this->path().data(), this->path().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    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::VerifyUTF8String(
      this->filename().data(), this->filename().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        4, this->filename(), target);
  }

  // optional int32 file_fraction = 5;
  if (has_file_fraction()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(5, this->file_fraction(), target);
  }

  // optional bytes md5 = 6;
  if (has_md5()) {
    target =
      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
        6, this->md5(), target);
  }

  // optional uint32 crc = 7;
  if (has_crc()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(7, this->crc(), target);
  }

  // optional int32 file_hash_type = 8;
  if (has_file_hash_type()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(8, this->file_hash_type(), target);
  }

  // optional int32 file_len = 9;
  if (has_file_len()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(9, this->file_len(), target);
  }

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

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

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  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 int32 file_fraction = 5;
    if (has_file_fraction()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->file_fraction());
    }

    // optional bytes md5 = 6;
    if (has_md5()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->md5());
    }

    // optional uint32 crc = 7;
    if (has_crc()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->crc());
    }

    // optional int32 file_hash_type = 8;
    if (has_file_hash_type()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->file_hash_type());
    }

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

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

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

  }
  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_file_fraction()) {
      set_file_fraction(from.file_fraction());
    }
    if (from.has_md5()) {
      set_md5(from.md5());
    }
    if (from.has_crc()) {
      set_crc(from.crc());
    }
    if (from.has_file_hash_type()) {
      set_file_hash_type(from.file_hash_type());
    }
  }
  if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
    if (from.has_file_len()) {
      set_file_len(from.file_len());
    }
    if (from.has_pack_file_id()) {
      set_pack_file_id(from.pack_file_id());
    }
    if (from.has_pack_file_number()) {
      set_pack_file_number(from.pack_file_number());
    }
  }
  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(file_fraction_, other->file_fraction_);
    std::swap(md5_, other->md5_);
    std::swap(crc_, other->crc_);
    std::swap(file_hash_type_, other->file_hash_type_);
    std::swap(file_len_, other->file_len_);
    std::swap(pack_file_id_, other->pack_file_id_);
    std::swap(pack_file_number_, other->pack_file_number_);
    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();
}

void CCLCMsg_LoadingProgress::InitAsDefaultInstance() {
}

CCLCMsg_LoadingProgress::CCLCMsg_LoadingProgress(const CCLCMsg_LoadingProgress& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

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

CCLCMsg_LoadingProgress::~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() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    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)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 progress = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &progress_)));
          set_has_progress();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void CCLCMsg_LoadingProgress::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // 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);
  }
}

::google::protobuf::uint8* CCLCMsg_LoadingProgress::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // 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);
  }
  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::kConvarsFieldNumber;
#endif  // !_MSC_VER

CCLCMsg_SplitPlayerConnect::CCLCMsg_SplitPlayerConnect()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void CCLCMsg_SplitPlayerConnect::InitAsDefaultInstance() {
  convars_ = const_cast< ::CMsg_CVars*>(&::CMsg_CVars::default_instance());
}

CCLCMsg_SplitPlayerConnect::CCLCMsg_SplitPlayerConnect(const CCLCMsg_SplitPlayerConnect& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void CCLCMsg_SplitPlayerConnect::SharedCtor() {
  _cached_size_ = 0;
  convars_ = NULL;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CCLCMsg_SplitPlayerConnect::~CCLCMsg_SplitPlayerConnect() {
  SharedDtor();
}

void CCLCMsg_SplitPlayerConnect::SharedDtor() {
  if (this != default_instance_) {
    delete convars_;
  }
}

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_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_convars()) {
      if (convars_ != NULL) convars_->::CMsg_CVars::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)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .CMsg_CVars convars = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_convars()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void CCLCMsg_SplitPlayerConnect::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional .CMsg_CVars convars = 1;
  if (has_convars()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->convars(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* CCLCMsg_SplitPlayerConnect::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional .CMsg_CVars convars = 1;
  if (has_convars()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->convars(), target);
  }

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

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

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

  }
  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_convars()) {
      mutable_convars()->::CMsg_CVars::MergeFrom(from.convars());
    }
  }
  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(convars_, other->convars_);
    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_CmdKeyValues::kKeyvaluesFieldNumber;
#endif  // !_MSC_VER

CCLCMsg_CmdKeyValues::CCLCMsg_CmdKeyValues()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void CCLCMsg_CmdKeyValues::InitAsDefaultInstance() {
}

CCLCMsg_CmdKeyValues::CCLCMsg_CmdKeyValues(const CCLCMsg_CmdKeyValues& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

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

CCLCMsg_CmdKeyValues::~CCLCMsg_CmdKeyValues() {
  SharedDtor();
}

void CCLCMsg_CmdKeyValues::SharedDtor() {
  if (keyvalues_ != &::google::protobuf::internal::kEmptyString) {
    delete keyvalues_;
  }
  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_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_keyvalues()) {
      if (keyvalues_ != &::google::protobuf::internal::kEmptyString) {
        keyvalues_->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)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional bytes keyvalues = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_keyvalues()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void CCLCMsg_CmdKeyValues::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional bytes keyvalues = 1;
  if (has_keyvalues()) {
    ::google::protobuf::internal::WireFormatLite::WriteBytes(
      1, this->keyvalues(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* CCLCMsg_CmdKeyValues::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional bytes keyvalues = 1;
  if (has_keyvalues()) {
    target =
      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
        1, this->keyvalues(), target);
  }

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

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional bytes keyvalues = 1;
    if (has_keyvalues()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->keyvalues());
    }

  }
  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_keyvalues()) {
      set_keyvalues(from.keyvalues());
    }
  }
  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(keyvalues_, other->keyvalues_);
    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::kIsOfficialValveServerFieldNumber;
const int CSVCMsg_ServerInfo::kIsHltvFieldNumber;
const int CSVCMsg_ServerInfo::kIsReplayFieldNumber;
const int CSVCMsg_ServerInfo::kIsRedirectingToProxyRelayFieldNumber;
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::kMapGroupNameFieldNumber;
const int CSVCMsg_ServerInfo::kSkyNameFieldNumber;
const int CSVCMsg_ServerInfo::kHostNameFieldNumber;
const int CSVCMsg_ServerInfo::kPublicIpFieldNumber;
const int CSVCMsg_ServerInfo::kUgcMapIdFieldNumber;
#endif  // !_MSC_VER

CSVCMsg_ServerInfo::CSVCMsg_ServerInfo()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void CSVCMsg_ServerInfo::InitAsDefaultInstance() {
}

CSVCMsg_ServerInfo::CSVCMsg_ServerInfo(const CSVCMsg_ServerInfo& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void CSVCMsg_ServerInfo::SharedCtor() {
  _cached_size_ = 0;
  protocol_ = 0;
  server_count_ = 0;
  is_dedicated_ = false;
  is_official_valve_server_ = false;
  is_hltv_ = false;
  is_replay_ = false;
  is_redirecting_to_proxy_relay_ = 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::kEmptyString);
  map_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  map_group_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  sky_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  host_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  public_ip_ = 0u;
  ugc_map_id_ = GOOGLE_ULONGLONG(0);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CSVCMsg_ServerInfo::~CSVCMsg_ServerInfo() {
  SharedDtor();
}

void CSVCMsg_ServerInfo::SharedDtor() {
  if (game_dir_ != &::google::protobuf::internal::kEmptyString) {
    delete game_dir_;
  }
  if (map_name_ != &::google::protobuf::internal::kEmptyString) {
    delete map_name_;
  }
  if (map_group_name_ != &::google::protobuf::internal::kEmptyString) {
    delete map_group_name_;
  }
  if (sky_name_ != &::google::protobuf::internal::kEmptyString) {
    delete sky_name_;
  }
  if (host_name_ != &::google::protobuf::internal::kEmptyString) {
    delete host_name_;
  }
  if (this != default_instance_) {
  }
}

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() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    protocol_ = 0;
    server_count_ = 0;
    is_dedicated_ = false;
    is_official_valve_server_ = false;
    is_hltv_ = false;
    is_replay_ = false;
    is_redirecting_to_proxy_relay_ = false;
    c_os_ = 0;
  }
  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
    map_crc_ = 0u;
    client_crc_ = 0u;
    string_table_crc_ = 0u;
    max_clients_ = 0;
    max_classes_ = 0;
    player_slot_ = 0;
    tick_interval_ = 0;
    if (has_game_dir()) {
      if (game_dir_ != &::google::protobuf::internal::kEmptyString) {
        game_dir_->clear();
      }
    }
  }
  if (_has_bits_[16 / 32] & (0xffu << (16 % 32))) {
    if (has_map_name()) {
      if (map_name_ != &::google::protobuf::internal::kEmptyString) {
        map_name_->clear();
      }
    }
    if (has_map_group_name()) {
      if (map_group_name_ != &::google::protobuf::internal::kEmptyString) {
        map_group_name_->clear();
      }
    }
    if (has_sky_name()) {
      if (sky_name_ != &::google::protobuf::internal::kEmptyString) {
        sky_name_->clear();
      }
    }
    if (has_host_name()) {
      if (host_name_ != &::google::protobuf::internal::kEmptyString) {
        host_name_->clear();
      }
    }
    public_ip_ = 0u;
    ugc_map_id_ = GOOGLE_ULONGLONG(0);
  }
  ::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)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 protocol = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &protocol_)));
          set_has_protocol();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(16)) goto parse_server_count;
        break;
      }

      // optional int32 server_count = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         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_uninterpreted;
        }
        if (input->ExpectTag(24)) goto parse_is_dedicated;
        break;
      }

      // optional bool is_dedicated = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         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_uninterpreted;
        }
        if (input->ExpectTag(32)) goto parse_is_official_valve_server;
        break;
      }

      // optional bool is_official_valve_server = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_is_official_valve_server:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &is_official_valve_server_)));
          set_has_is_official_valve_server();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(40)) goto parse_is_hltv;
        break;
      }

      // optional bool is_hltv = 5;
      case 5: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         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_uninterpreted;
        }
        if (input->ExpectTag(48)) goto parse_is_replay;
        break;
      }

      // optional bool is_replay = 6;
      case 6: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         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_uninterpreted;
        }
        if (input->ExpectTag(56)) goto parse_c_os;
        break;
      }

      // optional int32 c_os = 7;
      case 7: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         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_uninterpreted;
        }
        if (input->ExpectTag(69)) goto parse_map_crc;
        break;
      }

      // optional fixed32 map_crc = 8;
      case 8: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
         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_uninterpreted;
        }
        if (input->ExpectTag(77)) goto parse_client_crc;
        break;
      }

      // optional fixed32 client_crc = 9;
      case 9: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
         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_uninterpreted;
        }
        if (input->ExpectTag(85)) goto parse_string_table_crc;
        break;
      }

      // optional fixed32 string_table_crc = 10;
      case 10: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
         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_uninterpreted;
        }
        if (input->ExpectTag(88)) goto parse_max_clients;
        break;
      }

      // optional int32 max_clients = 11;
      case 11: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         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_uninterpreted;
        }
        if (input->ExpectTag(96)) goto parse_max_classes;
        break;
      }

      // optional int32 max_classes = 12;
      case 12: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         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_uninterpreted;
        }
        if (input->ExpectTag(104)) goto parse_player_slot;
        break;
      }

      // optional int32 player_slot = 13;
      case 13: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         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_uninterpreted;
        }
        if (input->ExpectTag(117)) goto parse_tick_interval;
        break;
      }

      // optional float tick_interval = 14;
      case 14: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
         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_uninterpreted;
        }
        if (input->ExpectTag(122)) goto parse_game_dir;
        break;
      }

      // optional string game_dir = 15;
      case 15: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_game_dir:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_game_dir()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->game_dir().data(), this->game_dir().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(130)) goto parse_map_name;
        break;
      }

      // optional string map_name = 16;
      case 16: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_map_name:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_map_name()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->map_name().data(), this->map_name().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(138)) goto parse_map_group_name;
        break;
      }

      // optional string map_group_name = 17;
      case 17: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_map_group_name:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_map_group_name()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->map_group_name().data(), this->map_group_name().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(146)) goto parse_sky_name;
        break;
      }

      // optional string sky_name = 18;
      case 18: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_sky_name:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_sky_name()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->sky_name().data(), this->sky_name().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(154)) goto parse_host_name;
        break;
      }

      // optional string host_name = 19;
      case 19: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_host_name:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_host_name()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->host_name().data(), this->host_name().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(160)) goto parse_public_ip;
        break;
      }

      // optional uint32 public_ip = 20;
      case 20: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_public_ip:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &public_ip_)));
          set_has_public_ip();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(168)) goto parse_is_redirecting_to_proxy_relay;
        break;
      }

      // optional bool is_redirecting_to_proxy_relay = 21;
      case 21: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_is_redirecting_to_proxy_relay:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &is_redirecting_to_proxy_relay_)));
          set_has_is_redirecting_to_proxy_relay();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(176)) goto parse_ugc_map_id;
        break;
      }

      // optional uint64 ugc_map_id = 22;
      case 22: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_ugc_map_id:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
                 input, &ugc_map_id_)));
          set_has_ugc_map_id();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void CSVCMsg_ServerInfo::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // 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_official_valve_server = 4;
  if (has_is_official_valve_server()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->is_official_valve_server(), output);
  }

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

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

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

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

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

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

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

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

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

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

  // optional string game_dir = 15;
  if (has_game_dir()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->game_dir().data(), this->game_dir().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      15, this->game_dir(), output);
  }

  // optional string map_name = 16;
  if (has_map_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->map_name().data(), this->map_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      16, this->map_name(), output);
  }

  // optional string map_group_name = 17;
  if (has_map_group_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->map_group_name().data(), this->map_group_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      17, this->map_group_name(), output);
  }

  // optional string sky_name = 18;
  if (has_sky_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->sky_name().data(), this->sky_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      18, this->sky_name(), output);
  }

  // optional string host_name = 19;
  if (has_host_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->host_name().data(), this->host_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      19, this->host_name(), output);
  }

  // optional uint32 public_ip = 20;
  if (has_public_ip()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(20, this->public_ip(), output);
  }

  // optional bool is_redirecting_to_proxy_relay = 21;
  if (has_is_redirecting_to_proxy_relay()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(21, this->is_redirecting_to_proxy_relay(), output);
  }

  // optional uint64 ugc_map_id = 22;
  if (has_ugc_map_id()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt64(22, this->ugc_map_id(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* CSVCMsg_ServerInfo::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // 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_official_valve_server = 4;
  if (has_is_official_valve_server()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(4, this->is_official_valve_server(), target);
  }

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

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

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

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

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

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

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

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

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

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

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

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

  // optional string map_group_name = 17;
  if (has_map_group_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->map_group_name().data(), this->map_group_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        17, this->map_group_name(), target);
  }

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

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

  // optional uint32 public_ip = 20;
  if (has_public_ip()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(20, this->public_ip(), target);
  }

  // optional bool is_redirecting_to_proxy_relay = 21;
  if (has_is_redirecting_to_proxy_relay()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(21, this->is_redirecting_to_proxy_relay(), target);
  }

  // optional uint64 ugc_map_id = 22;
  if (has_ugc_map_id()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(22, this->ugc_map_id(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  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_official_valve_server = 4;
    if (has_is_official_valve_server()) {
      total_size += 1 + 1;
    }

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

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

    // optional bool is_redirecting_to_proxy_relay = 21;
    if (has_is_redirecting_to_proxy_relay()) {
      total_size += 2 + 1;
    }

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

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

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

    // optional fixed32 string_table_crc = 10;
    if (has_string_table_crc()) {
      total_size += 1 + 4;
    }

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

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

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

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

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

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

    // optional string map_group_name = 17;
    if (has_map_group_name()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->map_group_name());
    }

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

    // optional string host_name = 19;
    if (has_host_name()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->host_name());
    }

    // optional uint32 public_ip = 20;
    if (has_public_ip()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->public_ip());
    }

    // optional uint64 ugc_map_id = 22;
    if (has_ugc_map_id()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::UInt64Size(
          this->ugc_map_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 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_official_valve_server()) {
      set_is_official_valve_server(from.is_official_valve_server());
    }
    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_is_redirecting_to_proxy_relay()) {
      set_is_redirecting_to_proxy_relay(from.is_redirecting_to_proxy_relay());
    }
    if (from.has_c_os()) {
      set_c_os(from.c_os());
    }
  }
  if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
    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_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_bits_[16 / 32] & (0xffu << (16 % 32))) {
    if (from.has_map_name()) {
      set_map_name(from.map_name());
    }
    if (from.has_map_group_name()) {
      set_map_group_name(from.map_group_name());
    }
    if (from.has_sky_name()) {
      set_sky_name(from.sky_name());
    }
    if (from.has_host_name()) {
      set_host_name(from.host_name());
    }
    if (from.has_public_ip()) {
      set_public_ip(from.public_ip());
    }
    if (from.has_ugc_map_id()) {
      set_ugc_map_id(from.ugc_map_id());
    }
  }
  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_official_valve_server_, other->is_official_valve_server_);
    std::swap(is_hltv_, other->is_hltv_);
    std::swap(is_replay_, other->is_replay_);
    std::swap(is_redirecting_to_proxy_relay_, other->is_redirecting_to_proxy_relay_);
    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(map_group_name_, other->map_group_name_);
    std::swap(sky_name_, other->sky_name_);
    std::swap(host_name_, other->host_name_);
    std::swap(public_ip_, other->public_ip_);
    std::swap(ugc_map_id_, other->ugc_map_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_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();
}

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);
}

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

CSVCMsg_ClassInfo_class_t::~CSVCMsg_ClassInfo_class_t() {
  SharedDtor();
}

void CSVCMsg_ClassInfo_class_t::SharedDtor() {
  if (data_table_name_ != &::google::protobuf::internal::kEmptyString) {
    delete data_table_name_;
  }
  if (class_name_ != &::google::protobuf::internal::kEmptyString) {
    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] & (0xffu << (0 % 32))) {
    class_id_ = 0;
    if (has_data_table_name()) {
      if (data_table_name_ != &::google::protobuf::internal::kEmptyString) {
        data_table_name_->clear();
      }
    }
    if (has_class_name()) {
      if (class_name_ != &::google::protobuf::internal::kEmptyString) {
        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)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 class_id = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &class_id_)));
          set_has_class_id();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_data_table_name;
        break;
      }

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

      // optional string class_name = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_class_name:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_class_name()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->class_name().data(), this->class_name().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void CSVCMsg_ClassInfo_class_t::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // 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::VerifyUTF8String(
      this->data_table_name().data(), this->data_table_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      2, this->data_table_name(), output);
  }

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

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* CSVCMsg_ClassInfo_class_t::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // 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::VerifyUTF8String(
      this->data_table_name().data(), this->data_table_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    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::VerifyUTF8String(
      this->class_name().data(), this->class_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        3, this->class_name(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  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();
}

void CSVCMsg_ClassInfo::InitAsDefaultInstance() {
}

CSVCMsg_ClassInfo::CSVCMsg_ClassInfo(const CSVCMsg_ClassInfo& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

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

CSVCMsg_ClassInfo::~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() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    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)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional bool create_on_client = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          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_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_classes;
        break;
      }

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

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void CSVCMsg_ClassInfo::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // 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);
  }
}

::google::protobuf::uint8* CSVCMsg_ClassInfo::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // 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);
  }
  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_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();
}

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);
}

void CSVCMsg_SendTable_sendprop_t::SharedCtor() {
  _cached_size_ = 0;
  type_ = 0;
  var_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  flags_ = 0;
  priority_ = 0;
  dt_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  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() {
  SharedDtor();
}

void CSVCMsg_SendTable_sendprop_t::SharedDtor() {
  if (var_name_ != &::google::protobuf::internal::kEmptyString) {
    delete var_name_;
  }
  if (dt_name_ != &::google::protobuf::internal::kEmptyString) {
    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() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    type_ = 0;
    if (has_var_name()) {
      if (var_name_ != &::google::protobuf::internal::kEmptyString) {
        var_name_->clear();
      }
    }
    flags_ = 0;
    priority_ = 0;
    if (has_dt_name()) {
      if (dt_name_ != &::google::protobuf::internal::kEmptyString) {
        dt_name_->clear();
      }
    }
    num_elements_ = 0;
    low_value_ = 0;
    high_value_ = 0;
  }
  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
    num_bits_ = 0;
  }
  ::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)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 type = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &type_)));
          set_has_type();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_var_name;
        break;
      }

      // optional string var_name = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_var_name:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_var_name()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->var_name().data(), this->var_name().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(24)) goto parse_flags;
        break;
      }

      // optional int32 flags = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         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_uninterpreted;
        }
        if (input->ExpectTag(32)) goto parse_priority;
        break;
      }

      // optional int32 priority = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         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_uninterpreted;
        }
        if (input->ExpectTag(42)) goto parse_dt_name;
        break;
      }

      // optional string dt_name = 5;
      case 5: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_dt_name:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_dt_name()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->dt_name().data(), this->dt_name().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(48)) goto parse_num_elements;
        break;
      }

      // optional int32 num_elements = 6;
      case 6: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         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_uninterpreted;
        }
        if (input->ExpectTag(61)) goto parse_low_value;
        break;
      }

      // optional float low_value = 7;
      case 7: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
         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_uninterpreted;
        }
        if (input->ExpectTag(69)) goto parse_high_value;
        break;
      }

      // optional float high_value = 8;
      case 8: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
         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_uninterpreted;
        }
        if (input->ExpectTag(72)) goto parse_num_bits;
        break;
      }

      // optional int32 num_bits = 9;
      case 9: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         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_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void CSVCMsg_SendTable_sendprop_t::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // 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::VerifyUTF8String(
      this->var_name().data(), this->var_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      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::VerifyUTF8String(
      this->dt_name().data(), this->dt_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      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);
  }
}

::google::protobuf::uint8* CSVCMsg_SendTable_sendprop_t::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // 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::VerifyUTF8String(
      this->var_name().data(), this->var_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    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::VerifyUTF8String(
      this->dt_name().data(), this->dt_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    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);
  }
  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();
}

void CSVCMsg_SendTable::InitAsDefaultInstance() {
}

CSVCMsg_SendTable::CSVCMsg_SendTable(const CSVCMsg_SendTable& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void CSVCMsg_SendTable::SharedCtor() {
  _cached_size_ = 0;
  is_end_ = false;
  net_table_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  needs_decoder_ = false;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CSVCMsg_SendTable::~CSVCMsg_SendTable() {
  SharedDtor();
}

void CSVCMsg_SendTable::SharedDtor() {
  if (net_table_name_ != &::google::protobuf::internal::kEmptyString) {
    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() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    is_end_ = false;
    if (has_net_table_name()) {
      if (net_table_name_ != &::google::protobuf::internal::kEmptyString) {
        net_table_name_->clear();
      }
    }
    needs_decoder_ = false;
  }
  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)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional bool is_end = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &is_end_)));
          set_has_is_end();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_net_table_name;
        break;
      }

      // optional string net_table_name = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_net_table_name:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_net_table_name()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->net_table_name().data(), this->net_table_name().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(24)) goto parse_needs_decoder;
        break;
      }

      // optional bool needs_decoder = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         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_uninterpreted;
        }
        if (input->ExpectTag(34)) goto parse_props;
        break;
      }

      // repeated .CSVCMsg_SendTable.sendprop_t props = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_props:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_props()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(34)) goto parse_props;
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void CSVCMsg_SendTable::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // 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::VerifyUTF8String(
      this->net_table_name().data(), this->net_table_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      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);
  }
}

::google::protobuf::uint8* CSVCMsg_SendTable::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // 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::VerifyUTF8String(
      this->net_table_name().data(), this->net_table_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    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);
  }
  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_Print::kTextFieldNumber;
#endif  // !_MSC_VER

CSVCMsg_Print::CSVCMsg_Print()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void CSVCMsg_Print::InitAsDefaultInstance() {
}

CSVCMsg_Print::CSVCMsg_Print(const CSVCMsg_Print& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

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

CSVCMsg_Print::~CSVCMsg_Print() {
  SharedDtor();
}

void CSVCMsg_Print::SharedDtor() {
  if (text_ != &::google::protobuf::internal::kEmptyString) {
    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_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_text()) {
      if (text_ != &::google::protobuf::internal::kEmptyString) {
        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)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional string text = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_text()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->text().data(), this->text().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

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

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

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

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  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_SetPause::kPausedFieldNumber;
#endif  // !_MSC_VER

CSVCMsg_SetPause::CSVCMsg_SetPause()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void CSVCMsg_SetPause::InitAsDefaultInstance() {
}

CSVCMsg_SetPause::CSVCMsg_SetPause(const CSVCMsg_SetPause& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

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

CSVCMsg_SetPause::~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() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    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)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional bool paused = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &paused_)));
          set_has_paused();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void CSVCMsg_SetPause::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // 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);
  }
}

::google::protobuf::uint8* CSVCMsg_SetPause::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // 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);
  }
  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_SetView::kEntityIndexFieldNumber;
#endif  // !_MSC_VER

CSVCMsg_SetView::CSVCMsg_SetView()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void CSVCMsg_SetView::InitAsDefaultInstance() {
}

CSVCMsg_SetView::CSVCMsg_SetView(const CSVCMsg_SetView& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

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

CSVCMsg_SetView::~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() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    entity_index_ = 0;
  }
  ::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)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 entity_index = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &entity_index_)));
          set_has_entity_index();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void CSVCMsg_SetView::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional int32 entity_index = 1;
  if (has_entity_index()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->entity_index(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* CSVCMsg_SetView::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional int32 entity_index = 1;
  if (has_entity_index()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->entity_index(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  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());
    }

  }
  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());
    }
  }
  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(_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_CreateStringTable::kNameFieldNumber;
const int CSVCMsg_CreateStringTable::kMaxEntriesFieldNumber;
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;
#endif  // !_MSC_VER

CSVCMsg_CreateStringTable::CSVCMsg_CreateStringTable()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void CSVCMsg_CreateStringTable::InitAsDefaultInstance() {
}

CSVCMsg_CreateStringTable::CSVCMsg_CreateStringTable(const CSVCMsg_CreateStringTable& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void CSVCMsg_CreateStringTable::SharedCtor() {
  _cached_size_ = 0;
  name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  max_entries_ = 0;
  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::kEmptyString);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CSVCMsg_CreateStringTable::~CSVCMsg_CreateStringTable() {
  SharedDtor();
}

void CSVCMsg_CreateStringTable::SharedDtor() {
  if (name_ != &::google::protobuf::internal::kEmptyString) {
    delete name_;
  }
  if (string_data_ != &::google::protobuf::internal::kEmptyString) {
    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() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_name()) {
      if (name_ != &::google::protobuf::internal::kEmptyString) {
        name_->clear();
      }
    }
    max_entries_ = 0;
    num_entries_ = 0;
    user_data_fixed_size_ = false;
    user_data_size_ = 0;
    user_data_size_bits_ = 0;
    flags_ = 0;
    if (has_string_data()) {
      if (string_data_ != &::google::protobuf::internal::kEmptyString) {
        string_data_->clear();
      }
    }
  }
  ::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)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional string name = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_name()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->name().data(), this->name().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(16)) goto parse_max_entries;
        break;
      }

      // optional int32 max_entries = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_max_entries:
          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_uninterpreted;
        }
        if (input->ExpectTag(24)) goto parse_num_entries;
        break;
      }

      // optional int32 num_entries = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         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_uninterpreted;
        }
        if (input->ExpectTag(32)) goto parse_user_data_fixed_size;
        break;
      }

      // optional bool user_data_fixed_size = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         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_uninterpreted;
        }
        if (input->ExpectTag(40)) goto parse_user_data_size;
        break;
      }

      // optional int32 user_data_size = 5;
      case 5: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         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_uninterpreted;
        }
        if (input->ExpectTag(48)) goto parse_user_data_size_bits;
        break;
      }

      // optional int32 user_data_size_bits = 6;
      case 6: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         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_uninterpreted;
        }
        if (input->ExpectTag(56)) goto parse_flags;
        break;
      }

      // optional int32 flags = 7;
      case 7: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         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_uninterpreted;
        }
        if (input->ExpectTag(66)) goto parse_string_data;
        break;
      }

      // optional bytes string_data = 8;
      case 8: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_string_data:
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_string_data()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void CSVCMsg_CreateStringTable::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional string name = 1;
  if (has_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->name().data(), this->name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      1, this->name(), output);
  }

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

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

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

  // optional int32 user_data_size = 5;
  if (has_user_data_size()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(5, this->user_data_size(), output);
  }

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

  // optional int32 flags = 7;
  if (has_flags()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(7, this->flags(), output);
  }

  // optional bytes string_data = 8;
  if (has_string_data()) {
    ::google::protobuf::internal::WireFormatLite::WriteBytes(
      8, this->string_data(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* CSVCMsg_CreateStringTable::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional string name = 1;
  if (has_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->name().data(), this->name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        1, this->name(), target);
  }

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

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

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

  // optional int32 user_data_size = 5;
  if (has_user_data_size()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(5, this->user_data_size(), target);
  }

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

  // optional int32 flags = 7;
  if (has_flags()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(7, this->flags(), target);
  }

  // optional bytes string_data = 8;
  if (has_string_data()) {
    target =
      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
        8, this->string_data(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  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 max_entries = 2;
    if (has_max_entries()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->max_entries());
    }

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

    // optional bool user_data_fixed_size = 4;
    if (has_user_data_fixed_size()) {
      total_size += 1 + 1;
    }

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

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

    // optional int32 flags = 7;
    if (has_flags()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->flags());
    }

    // optional bytes string_data = 8;
    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_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_max_entries()) {
      set_max_entries(from.max_entries());
    }
    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());
    }
  }
  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(max_entries_, other->max_entries_);
    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(_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();
}

void CSVCMsg_UpdateStringTable::InitAsDefaultInstance() {
}

CSVCMsg_UpdateStringTable::CSVCMsg_UpdateStringTable(const CSVCMsg_UpdateStringTable& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void CSVCMsg_UpdateStringTable::SharedCtor() {
  _cached_size_ = 0;
  table_id_ = 0;
  num_changed_entries_ = 0;
  string_data_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CSVCMsg_UpdateStringTable::~CSVCMsg_UpdateStringTable() {
  SharedDtor();
}

void CSVCMsg_UpdateStringTable::SharedDtor() {
  if (string_data_ != &::google::protobuf::internal::kEmptyString) {
    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() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    table_id_ = 0;
    num_changed_entries_ = 0;
    if (has_string_data()) {
      if (string_data_ != &::google::protobuf::internal::kEmptyString) {
        string_data_->clear();
      }
    }
  }
  ::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)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 table_id = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &table_id_)));
          set_has_table_id();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(16)) goto parse_num_changed_entries;
        break;
      }

      // optional int32 num_changed_entries = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         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_uninterpreted;
        }
        if (input->ExpectTag(26)) goto parse_string_data;
        break;
      }

      // optional bytes string_data = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_string_data:
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_string_data()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void CSVCMsg_UpdateStringTable::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // 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::WriteBytes(
      3, this->string_data(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* CSVCMsg_UpdateStringTable::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // 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);
  }
  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_VoiceInit::kQualityFieldNumber;
const int CSVCMsg_VoiceInit::kCodecFieldNumber;
const int CSVCMsg_VoiceInit::kVersionFieldNumber;
#endif  // !_MSC_VER

CSVCMsg_VoiceInit::CSVCMsg_VoiceInit()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void CSVCMsg_VoiceInit::InitAsDefaultInstance() {
}

CSVCMsg_VoiceInit::CSVCMsg_VoiceInit(const CSVCMsg_VoiceInit& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

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

CSVCMsg_VoiceInit::~CSVCMsg_VoiceInit() {
  SharedDtor();
}

void CSVCMsg_VoiceInit::SharedDtor() {
  if (codec_ != &::google::protobuf::internal::kEmptyString) {
    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() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    quality_ = 0;
    if (has_codec()) {
      if (codec_ != &::google::protobuf::internal::kEmptyString) {
        codec_->clear();
      }
    }
    version_ = 0;
  }
  ::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)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 quality = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &quality_)));
          set_has_quality();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_codec;
        break;
      }

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

      // optional int32 version = 3 [default = 0];
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         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_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void CSVCMsg_VoiceInit::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // 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::VerifyUTF8String(
      this->codec().data(), this->codec().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      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);
  }
}

::google::protobuf::uint8* CSVCMsg_VoiceInit::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // 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::VerifyUTF8String(
      this->codec().data(), this->codec().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    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);
  }
  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_VoiceData::kClientFieldNumber;
const int CSVCMsg_VoiceData::kProximityFieldNumber;
const int CSVCMsg_VoiceData::kXuidFieldNumber;
const int CSVCMsg_VoiceData::kAudibleMaskFieldNumber;
const int CSVCMsg_VoiceData::kVoiceDataFieldNumber;
const int CSVCMsg_VoiceData::kCasterFieldNumber;
const int CSVCMsg_VoiceData::kFormatFieldNumber;
const int CSVCMsg_VoiceData::kSequenceBytesFieldNumber;
const int CSVCMsg_VoiceData::kSectionNumberFieldNumber;
const int CSVCMsg_VoiceData::kUncompressedSampleOffsetFieldNumber;
#endif  // !_MSC_VER

CSVCMsg_VoiceData::CSVCMsg_VoiceData()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void CSVCMsg_VoiceData::InitAsDefaultInstance() {
}

CSVCMsg_VoiceData::CSVCMsg_VoiceData(const CSVCMsg_VoiceData& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void CSVCMsg_VoiceData::SharedCtor() {
  _cached_size_ = 0;
  client_ = 0;
  proximity_ = false;
  xuid_ = GOOGLE_ULONGLONG(0);
  audible_mask_ = 0;
  voice_data_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  caster_ = false;
  format_ = 1;
  sequence_bytes_ = 0;
  section_number_ = 0u;
  uncompressed_sample_offset_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CSVCMsg_VoiceData::~CSVCMsg_VoiceData() {
  SharedDtor();
}

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

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() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    client_ = 0;
    proximity_ = false;
    xuid_ = GOOGLE_ULONGLONG(0);
    audible_mask_ = 0;
    if (has_voice_data()) {
      if (voice_data_ != &::google::protobuf::internal::kEmptyString) {
        voice_data_->clear();
      }
    }
    caster_ = false;
    format_ = 1;
    sequence_bytes_ = 0;
  }
  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
    section_number_ = 0u;
    uncompressed_sample_offset_ = 0u;
  }
  ::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)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 client = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &client_)));
          set_has_client();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(16)) goto parse_proximity;
        break;
      }

      // optional bool proximity = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_proximity:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &proximity_)));
          set_has_proximity();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(25)) goto parse_xuid;
        break;
      }

      // optional fixed64 xuid = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
         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_uninterpreted;
        }
        if (input->ExpectTag(32)) goto parse_audible_mask;
        break;
      }

      // optional int32 audible_mask = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         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_uninterpreted;
        }
        if (input->ExpectTag(42)) goto parse_voice_data;
        break;
      }

      // optional bytes voice_data = 5;
      case 5: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_voice_data:
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_voice_data()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(48)) goto parse_caster;
        break;
      }

      // optional bool caster = 6;
      case 6: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_caster:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &caster_)));
          set_has_caster();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(56)) goto parse_format;
        break;
      }

      // optional .VoiceDataFormat_t format = 7 [default = VOICEDATA_FORMAT_ENGINE];
      case 7: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_format:
          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(7, value);
          }
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(64)) goto parse_sequence_bytes;
        break;
      }

      // optional int32 sequence_bytes = 8;
      case 8: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         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_uninterpreted;
        }
        if (input->ExpectTag(72)) goto parse_section_number;
        break;
      }

      // optional uint32 section_number = 9;
      case 9: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         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_uninterpreted;
        }
        if (input->ExpectTag(80)) goto parse_uncompressed_sample_offset;
        break;
      }

      // optional uint32 uncompressed_sample_offset = 10;
      case 10: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         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_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void CSVCMsg_VoiceData::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional int32 client = 1;
  if (has_client()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->client(), output);
  }

  // optional bool proximity = 2;
  if (has_proximity()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->proximity(), output);
  }

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

  // optional int32 audible_mask = 4;
  if (has_audible_mask()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->audible_mask(), output);
  }

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

  // optional bool caster = 6;
  if (has_caster()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(6, this->caster(), output);
  }

  // optional .VoiceDataFormat_t format = 7 [default = VOICEDATA_FORMAT_ENGINE];
  if (has_format()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      7, this->format(), output);
  }

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

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

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

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* CSVCMsg_VoiceData::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional int32 client = 1;
  if (has_client()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->client(), target);
  }

  // optional bool proximity = 2;
  if (has_proximity()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->proximity(), target);
  }

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

  // optional int32 audible_mask = 4;
  if (has_audible_mask()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(4, this->audible_mask(), target);
  }

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

  // optional bool caster = 6;
  if (has_caster()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(6, this->caster(), target);
  }

  // optional .VoiceDataFormat_t format = 7 [default = VOICEDATA_FORMAT_ENGINE];
  if (has_format()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      7, this->format(), target);
  }

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

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

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

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

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

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

    // optional bool proximity = 2;
    if (has_proximity()) {
      total_size += 1 + 1;
    }

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

    // optional int32 audible_mask = 4;
    if (has_audible_mask()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->audible_mask());
    }

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

    // optional bool caster = 6;
    if (has_caster()) {
      total_size += 1 + 1;
    }

    // optional .VoiceDataFormat_t format = 7 [default = VOICEDATA_FORMAT_ENGINE];
    if (has_format()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->format());
    }

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

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

    // optional uint32 uncompressed_sample_offset = 10;
    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 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_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_voice_data()) {
      set_voice_data(from.voice_data());
    }
    if (from.has_caster()) {
      set_caster(from.caster());
    }
    if (from.has_format()) {
      set_format(from.format());
    }
    if (from.has_sequence_bytes()) {
      set_sequence_bytes(from.sequence_bytes());
    }
  }
  if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
    if (from.has_section_number()) {
      set_section_number(from.section_number());
    }
    if (from.has_uncompressed_sample_offset()) {
      set_uncompressed_sample_offset(from.uncompressed_sample_offset());
    }
  }
  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(client_, other->client_);
    std::swap(proximity_, other->proximity_);
    std::swap(xuid_, other->xuid_);
    std::swap(audible_mask_, other->audible_mask_);
    std::swap(voice_data_, other->voice_data_);
    std::swap(caster_, other->caster_);
    std::swap(format_, other->format_);
    std::swap(sequence_bytes_, other->sequence_bytes_);
    std::swap(section_number_, other->section_number_);
    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 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_FixAngle::kRelativeFieldNumber;
const int CSVCMsg_FixAngle::kAngleFieldNumber;
#endif  // !_MSC_VER

CSVCMsg_FixAngle::CSVCMsg_FixAngle()
  : ::google::protobuf::Message() {
  SharedCtor();
}

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);
}

void CSVCMsg_FixAngle::SharedCtor() {
  _cached_size_ = 0;
  relative_ = false;
  angle_ = NULL;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CSVCMsg_FixAngle::~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] & (0xffu << (0 % 32))) {
    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)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional bool relative = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &relative_)));
          set_has_relative();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_angle;
        break;
      }

      // optional .CMsgQAngle angle = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_angle:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_angle()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void CSVCMsg_FixAngle::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // 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);
  }
}

::google::protobuf::uint8* CSVCMsg_FixAngle::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // 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);
  }
  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();
}

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);
}

void CSVCMsg_CrosshairAngle::SharedCtor() {
  _cached_size_ = 0;
  angle_ = NULL;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CSVCMsg_CrosshairAngle::~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_bits_[0 / 32] & (0xffu << (0 % 32))) {
    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)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .CMsgQAngle angle = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_angle()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void CSVCMsg_CrosshairAngle::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // 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);
  }
}

::google::protobuf::uint8* CSVCMsg_CrosshairAngle::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // 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);
  }
  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_Prefetch::kSoundIndexFieldNumber;
#endif  // !_MSC_VER

CSVCMsg_Prefetch::CSVCMsg_Prefetch()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void CSVCMsg_Prefetch::InitAsDefaultInstance() {
}

CSVCMsg_Prefetch::CSVCMsg_Prefetch(const CSVCMsg_Prefetch& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

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

CSVCMsg_Prefetch::~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() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    sound_index_ = 0;
  }
  ::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)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 sound_index = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &sound_index_)));
          set_has_sound_index();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void CSVCMsg_Prefetch::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional int32 sound_index = 1;
  if (has_sound_index()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->sound_index(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* CSVCMsg_Prefetch::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional int32 sound_index = 1;
  if (has_sound_index()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->sound_index(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  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());
    }

  }
  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());
    }
  }
  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(_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_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();
}

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);
}

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() {
  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() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_pos()) {
      if (pos_ != NULL) pos_->::CMsgVector::Clear();
    }
    decal_texture_index_ = 0;
    entity_index_ = 0;
    model_index_ = 0;
    low_priority_ = false;
  }
  ::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)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .CMsgVector pos = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_pos()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(16)) goto parse_decal_texture_index;
        break;
      }

      // optional int32 decal_texture_index = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         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_uninterpreted;
        }
        if (input->ExpectTag(24)) goto parse_entity_index;
        break;
      }

      // optional int32 entity_index = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         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_uninterpreted;
        }
        if (input->ExpectTag(32)) goto parse_model_index;
        break;
      }

      // optional int32 model_index = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         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_uninterpreted;
        }
        if (input->ExpectTag(40)) goto parse_low_priority;
        break;
      }

      // optional bool low_priority = 5;
      case 5: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         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_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void CSVCMsg_BSPDecal::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // 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);
  }
}

::google::protobuf::uint8* CSVCMsg_BSPDecal::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // 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);
  }
  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();
}

void CSVCMsg_SplitScreen::InitAsDefaultInstance() {
}

CSVCMsg_SplitScreen::CSVCMsg_SplitScreen(const CSVCMsg_SplitScreen& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

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() {
  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() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    type_ = 0;
    slot_ = 0;
    player_index_ = 0;
  }
  ::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)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .ESplitScreenMessageType type = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::ESplitScreenMessageType_IsValid(value)) {
            set_type(static_cast< ::ESplitScreenMessageType >(value));
          } else {
            mutable_unknown_fields()->AddVarint(1, value);
          }
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(16)) goto parse_slot;
        break;
      }

      // optional int32 slot = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         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_uninterpreted;
        }
        if (input->ExpectTag(24)) goto parse_player_index;
        break;
      }

      // optional int32 player_index = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         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_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void CSVCMsg_SplitScreen::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional .ESplitScreenMessageType type = 1;
  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);
  }
}

::google::protobuf::uint8* CSVCMsg_SplitScreen::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional .ESplitScreenMessageType type = 1;
  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);
  }
  return target;
}

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional .ESplitScreenMessageType type = 1;
    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();
}

void CSVCMsg_GetCvarValue::InitAsDefaultInstance() {
}

CSVCMsg_GetCvarValue::CSVCMsg_GetCvarValue(const CSVCMsg_GetCvarValue& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void CSVCMsg_GetCvarValue::SharedCtor() {
  _cached_size_ = 0;
  cookie_ = 0;
  cvar_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CSVCMsg_GetCvarValue::~CSVCMsg_GetCvarValue() {
  SharedDtor();
}

void CSVCMsg_GetCvarValue::SharedDtor() {
  if (cvar_name_ != &::google::protobuf::internal::kEmptyString) {
    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] & (0xffu << (0 % 32))) {
    cookie_ = 0;
    if (has_cvar_name()) {
      if (cvar_name_ != &::google::protobuf::internal::kEmptyString) {
        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)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 cookie = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &cookie_)));
          set_has_cookie();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_cvar_name;
        break;
      }

      // optional string cvar_name = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_cvar_name:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_cvar_name()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->cvar_name().data(), this->cvar_name().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void CSVCMsg_GetCvarValue::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // 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::VerifyUTF8String(
      this->cvar_name().data(), this->cvar_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      2, this->cvar_name(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* CSVCMsg_GetCvarValue::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // 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::VerifyUTF8String(
      this->cvar_name().data(), this->cvar_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        2, this->cvar_name(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  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();
}

void CSVCMsg_Menu::InitAsDefaultInstance() {
}

CSVCMsg_Menu::CSVCMsg_Menu(const CSVCMsg_Menu& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void CSVCMsg_Menu::SharedCtor() {
  _cached_size_ = 0;
  dialog_type_ = 0;
  menu_key_values_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CSVCMsg_Menu::~CSVCMsg_Menu() {
  SharedDtor();
}

void CSVCMsg_Menu::SharedDtor() {
  if (menu_key_values_ != &::google::protobuf::internal::kEmptyString) {
    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] & (0xffu << (0 % 32))) {
    dialog_type_ = 0;
    if (has_menu_key_values()) {
      if (menu_key_values_ != &::google::protobuf::internal::kEmptyString) {
        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)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 dialog_type = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &dialog_type_)));
          set_has_dialog_type();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_menu_key_values;
        break;
      }

      // optional bytes menu_key_values = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_menu_key_values:
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_menu_key_values()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void CSVCMsg_Menu::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // 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::WriteBytes(
      2, this->menu_key_values(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* CSVCMsg_Menu::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // 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);
  }
  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_UserMessage::kMsgTypeFieldNumber;
const int CSVCMsg_UserMessage::kMsgDataFieldNumber;
const int CSVCMsg_UserMessage::kPassthroughFieldNumber;
#endif  // !_MSC_VER

CSVCMsg_UserMessage::CSVCMsg_UserMessage()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void CSVCMsg_UserMessage::InitAsDefaultInstance() {
}

CSVCMsg_UserMessage::CSVCMsg_UserMessage(const CSVCMsg_UserMessage& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void CSVCMsg_UserMessage::SharedCtor() {
  _cached_size_ = 0;
  msg_type_ = 0;
  msg_data_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  passthrough_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CSVCMsg_UserMessage::~CSVCMsg_UserMessage() {
  SharedDtor();
}

void CSVCMsg_UserMessage::SharedDtor() {
  if (msg_data_ != &::google::protobuf::internal::kEmptyString) {
    delete msg_data_;
  }
  if (this != default_instance_) {
  }
}

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

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

CSVCMsg_UserMessage* CSVCMsg_UserMessage::default_instance_ = NULL;

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

void CSVCMsg_UserMessage::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    msg_type_ = 0;
    if (has_msg_data()) {
      if (msg_data_ != &::google::protobuf::internal::kEmptyString) {
        msg_data_->clear();
      }
    }
    passthrough_ = 0;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool CSVCMsg_UserMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 msg_type = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &msg_type_)));
          set_has_msg_type();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_msg_data;
        break;
      }

      // optional bytes msg_data = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_msg_data:
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_msg_data()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(24)) goto parse_passthrough;
        break;
      }

      // optional int32 passthrough = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_passthrough:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &passthrough_)));
          set_has_passthrough();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

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

  // optional bytes msg_data = 2;
  if (has_msg_data()) {
    ::google::protobuf::internal::WireFormatLite::WriteBytes(
      2, this->msg_data(), output);
  }

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

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

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

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

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

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

int CSVCMsg_UserMessage::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 msg_data = 2;
    if (has_msg_data()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->msg_data());
    }

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

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

void CSVCMsg_UserMessage::MergeFrom(const CSVCMsg_UserMessage& 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_msg_data()) {
      set_msg_data(from.msg_data());
    }
    if (from.has_passthrough()) {
      set_passthrough(from.passthrough());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

bool CSVCMsg_UserMessage::IsInitialized() const {

  return true;
}

void CSVCMsg_UserMessage::Swap(CSVCMsg_UserMessage* other) {
  if (other != this) {
    std::swap(msg_type_, other->msg_type_);
    std::swap(msg_data_, other->msg_data_);
    std::swap(passthrough_, other->passthrough_);
    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_UserMessage::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CSVCMsg_UserMessage_descriptor_;
  metadata.reflection = CSVCMsg_UserMessage_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int CSVCMsg_PaintmapData::kPaintmapFieldNumber;
#endif  // !_MSC_VER

CSVCMsg_PaintmapData::CSVCMsg_PaintmapData()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void CSVCMsg_PaintmapData::InitAsDefaultInstance() {
}

CSVCMsg_PaintmapData::CSVCMsg_PaintmapData(const CSVCMsg_PaintmapData& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void CSVCMsg_PaintmapData::SharedCtor() {
  _cached_size_ = 0;
  paintmap_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CSVCMsg_PaintmapData::~CSVCMsg_PaintmapData() {
  SharedDtor();
}

void CSVCMsg_PaintmapData::SharedDtor() {
  if (paintmap_ != &::google::protobuf::internal::kEmptyString) {
    delete paintmap_;
  }
  if (this != default_instance_) {
  }
}

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

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

CSVCMsg_PaintmapData* CSVCMsg_PaintmapData::default_instance_ = NULL;

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

void CSVCMsg_PaintmapData::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_paintmap()) {
      if (paintmap_ != &::google::protobuf::internal::kEmptyString) {
        paintmap_->clear();
      }
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool CSVCMsg_PaintmapData::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional bytes paintmap = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_paintmap()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void CSVCMsg_PaintmapData::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional bytes paintmap = 1;
  if (has_paintmap()) {
    ::google::protobuf::internal::WireFormatLite::WriteBytes(
      1, this->paintmap(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* CSVCMsg_PaintmapData::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional bytes paintmap = 1;
  if (has_paintmap()) {
    target =
      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
        1, this->paintmap(), target);
  }

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

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional bytes paintmap = 1;
    if (has_paintmap()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->paintmap());
    }

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

void CSVCMsg_PaintmapData::MergeFrom(const CSVCMsg_PaintmapData& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_paintmap()) {
      set_paintmap(from.paintmap());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

bool CSVCMsg_PaintmapData::IsInitialized() const {

  return true;
}

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


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

#ifndef _MSC_VER
const int CSVCMsg_GameEvent_key_t::kTypeFieldNumber;
const int CSVCMsg_GameEvent_key_t::kValStringFieldNumber;
const int CSVCMsg_GameEvent_key_t::kValFloatFieldNumber;
const int CSVCMsg_GameEvent_key_t::kValLongFieldNumber;
const int CSVCMsg_GameEvent_key_t::kValShortFieldNumber;
const int CSVCMsg_GameEvent_key_t::kValByteFieldNumber;
const int CSVCMsg_GameEvent_key_t::kValBoolFieldNumber;
const int CSVCMsg_GameEvent_key_t::kValUint64FieldNumber;
const int CSVCMsg_GameEvent_key_t::kValWstringFieldNumber;
#endif  // !_MSC_VER

CSVCMsg_GameEvent_key_t::CSVCMsg_GameEvent_key_t()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void CSVCMsg_GameEvent_key_t::InitAsDefaultInstance() {
}

CSVCMsg_GameEvent_key_t::CSVCMsg_GameEvent_key_t(const CSVCMsg_GameEvent_key_t& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void CSVCMsg_GameEvent_key_t::SharedCtor() {
  _cached_size_ = 0;
  type_ = 0;
  val_string_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  val_float_ = 0;
  val_long_ = 0;
  val_short_ = 0;
  val_byte_ = 0;
  val_bool_ = false;
  val_uint64_ = GOOGLE_ULONGLONG(0);
  val_wstring_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CSVCMsg_GameEvent_key_t::~CSVCMsg_GameEvent_key_t() {
  SharedDtor();
}

void CSVCMsg_GameEvent_key_t::SharedDtor() {
  if (val_string_ != &::google::protobuf::internal::kEmptyString) {
    delete val_string_;
  }
  if (val_wstring_ != &::google::protobuf::internal::kEmptyString) {
    delete val_wstring_;
  }
  if (this != default_instance_) {
  }
}

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

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

CSVCMsg_GameEvent_key_t* CSVCMsg_GameEvent_key_t::default_instance_ = NULL;

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

void CSVCMsg_GameEvent_key_t::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    type_ = 0;
    if (has_val_string()) {
      if (val_string_ != &::google::protobuf::internal::kEmptyString) {
        val_string_->clear();
      }
    }
    val_float_ = 0;
    val_long_ = 0;
    val_short_ = 0;
    val_byte_ = 0;
    val_bool_ = false;
    val_uint64_ = GOOGLE_ULONGLONG(0);
  }
  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
    if (has_val_wstring()) {
      if (val_wstring_ != &::google::protobuf::internal::kEmptyString) {
        val_wstring_->clear();
      }
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool CSVCMsg_GameEvent_key_t::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 type = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &type_)));
          set_has_type();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_val_string;
        break;
      }

      // optional string val_string = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_val_string:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_val_string()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->val_string().data(), this->val_string().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(29)) goto parse_val_float;
        break;
      }

      // optional float val_float = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
         parse_val_float:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &val_float_)));
          set_has_val_float();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(32)) goto parse_val_long;
        break;
      }

      // optional int32 val_long = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_val_long:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &val_long_)));
          set_has_val_long();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(40)) goto parse_val_short;
        break;
      }

      // optional int32 val_short = 5;
      case 5: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_val_short:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &val_short_)));
          set_has_val_short();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(48)) goto parse_val_byte;
        break;
      }

      // optional int32 val_byte = 6;
      case 6: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_val_byte:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &val_byte_)));
          set_has_val_byte();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(56)) goto parse_val_bool;
        break;
      }

      // optional bool val_bool = 7;
      case 7: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_val_bool:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &val_bool_)));
          set_has_val_bool();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(64)) goto parse_val_uint64;
        break;
      }

      // optional uint64 val_uint64 = 8;
      case 8: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_val_uint64:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
                 input, &val_uint64_)));
          set_has_val_uint64();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(74)) goto parse_val_wstring;
        break;
      }

      // optional bytes val_wstring = 9;
      case 9: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_val_wstring:
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_val_wstring()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void CSVCMsg_GameEvent_key_t::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional int32 type = 1;
  if (has_type()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->type(), output);
  }

  // optional string val_string = 2;
  if (has_val_string()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->val_string().data(), this->val_string().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      2, this->val_string(), output);
  }

  // optional float val_float = 3;
  if (has_val_float()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(3, this->val_float(), output);
  }

  // optional int32 val_long = 4;
  if (has_val_long()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->val_long(), output);
  }

  // optional int32 val_short = 5;
  if (has_val_short()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(5, this->val_short(), output);
  }

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

  // optional bool val_bool = 7;
  if (has_val_bool()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(7, this->val_bool(), output);
  }

  // optional uint64 val_uint64 = 8;
  if (has_val_uint64()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt64(8, this->val_uint64(), output);
  }

  // optional bytes val_wstring = 9;
  if (has_val_wstring()) {
    ::google::protobuf::internal::WireFormatLite::WriteBytes(
      9, this->val_wstring(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* CSVCMsg_GameEvent_key_t::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional int32 type = 1;
  if (has_type()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->type(), target);
  }

  // optional string val_string = 2;
  if (has_val_string()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->val_string().data(), this->val_string().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        2, this->val_string(), target);
  }

  // optional float val_float = 3;
  if (has_val_float()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(3, this->val_float(), target);
  }

  // optional int32 val_long = 4;
  if (has_val_long()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(4, this->val_long(), target);
  }

  // optional int32 val_short = 5;
  if (has_val_short()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(5, this->val_short(), target);
  }

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

  // optional bool val_bool = 7;
  if (has_val_bool()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(7, this->val_bool(), target);
  }

  // optional uint64 val_uint64 = 8;
  if (has_val_uint64()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(8, this->val_uint64(), target);
  }

  // optional bytes val_wstring = 9;
  if (has_val_wstring()) {
    target =
      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
        9, this->val_wstring(), target);
  }

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

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

    // optional float val_float = 3;
    if (has_val_float()) {
      total_size += 1 + 4;
    }

    // optional int32 val_long = 4;
    if (has_val_long()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->val_long());
    }

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

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

    // optional bool val_bool = 7;
    if (has_val_bool()) {
      total_size += 1 + 1;
    }

    // optional uint64 val_uint64 = 8;
    if (has_val_uint64()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt64Size(
          this->val_uint64());
    }

  }
  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
    // optional bytes val_wstring = 9;
    if (has_val_wstring()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->val_wstring());
    }

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

void CSVCMsg_GameEvent_key_t::MergeFrom(const CSVCMsg_GameEvent_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_val_string()) {
      set_val_string(from.val_string());
    }
    if (from.has_val_float()) {
      set_val_float(from.val_float());
    }
    if (from.has_val_long()) {
      set_val_long(from.val_long());
    }
    if (from.has_val_short()) {
      set_val_short(from.val_short());
    }
    if (from.has_val_byte()) {
      set_val_byte(from.val_byte());
    }
    if (from.has_val_bool()) {
      set_val_bool(from.val_bool());
    }
    if (from.has_val_uint64()) {
      set_val_uint64(from.val_uint64());
    }
  }
  if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
    if (from.has_val_wstring()) {
      set_val_wstring(from.val_wstring());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

bool CSVCMsg_GameEvent_key_t::IsInitialized() const {

  return true;
}

void CSVCMsg_GameEvent_key_t::Swap(CSVCMsg_GameEvent_key_t* other) {
  if (other != this) {
    std::swap(type_, other->type_);
    std::swap(val_string_, other->val_string_);
    std::swap(val_float_, other->val_float_);
    std::swap(val_long_, other->val_long_);
    std::swap(val_short_, other->val_short_);
    std::swap(val_byte_, other->val_byte_);
    std::swap(val_bool_, other->val_bool_);
    std::swap(val_uint64_, other->val_uint64_);
    std::swap(val_wstring_, other->val_wstring_);
    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_GameEvent_key_t::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CSVCMsg_GameEvent_key_t_descriptor_;
  metadata.reflection = CSVCMsg_GameEvent_key_t_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int CSVCMsg_GameEvent::kEventNameFieldNumber;
const int CSVCMsg_GameEvent::kEventidFieldNumber;
const int CSVCMsg_GameEvent::kKeysFieldNumber;
const int CSVCMsg_GameEvent::kPassthroughFieldNumber;
#endif  // !_MSC_VER

CSVCMsg_GameEvent::CSVCMsg_GameEvent()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void CSVCMsg_GameEvent::InitAsDefaultInstance() {
}

CSVCMsg_GameEvent::CSVCMsg_GameEvent(const CSVCMsg_GameEvent& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void CSVCMsg_GameEvent::SharedCtor() {
  _cached_size_ = 0;
  event_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  eventid_ = 0;
  passthrough_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CSVCMsg_GameEvent::~CSVCMsg_GameEvent() {
  SharedDtor();
}

void CSVCMsg_GameEvent::SharedDtor() {
  if (event_name_ != &::google::protobuf::internal::kEmptyString) {
    delete event_name_;
  }
  if (this != default_instance_) {
  }
}

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

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

CSVCMsg_GameEvent* CSVCMsg_GameEvent::default_instance_ = NULL;

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

void CSVCMsg_GameEvent::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_event_name()) {
      if (event_name_ != &::google::protobuf::internal::kEmptyString) {
        event_name_->clear();
      }
    }
    eventid_ = 0;
    passthrough_ = 0;
  }
  keys_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool CSVCMsg_GameEvent::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional string event_name = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_event_name()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->event_name().data(), this->event_name().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(16)) goto parse_eventid;
        break;
      }

      // optional int32 eventid = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_eventid:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &eventid_)));
          set_has_eventid();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(26)) goto parse_keys;
        break;
      }

      // repeated .CSVCMsg_GameEvent.key_t keys = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_keys:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_keys()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(26)) goto parse_keys;
        if (input->ExpectTag(32)) goto parse_passthrough;
        break;
      }

      // optional int32 passthrough = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_passthrough:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &passthrough_)));
          set_has_passthrough();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void CSVCMsg_GameEvent::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional string event_name = 1;
  if (has_event_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->event_name().data(), this->event_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      1, this->event_name(), output);
  }

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

  // repeated .CSVCMsg_GameEvent.key_t keys = 3;
  for (int i = 0; i < this->keys_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      3, this->keys(i), output);
  }

  // optional int32 passthrough = 4;
  if (has_passthrough()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->passthrough(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* CSVCMsg_GameEvent::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional string event_name = 1;
  if (has_event_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->event_name().data(), this->event_name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        1, this->event_name(), target);
  }

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

  // repeated .CSVCMsg_GameEvent.key_t keys = 3;
  for (int i = 0; i < this->keys_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        3, this->keys(i), target);
  }

  // optional int32 passthrough = 4;
  if (has_passthrough()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(4, this->passthrough(), target);
  }

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

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

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

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

    // optional int32 passthrough = 4;
    if (has_passthrough()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->passthrough());
    }

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

void CSVCMsg_GameEvent::MergeFrom(const CSVCMsg_GameEvent& from) {
  GOOGLE_CHECK_NE(&from, this);
  keys_.MergeFrom(from.keys_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_event_name()) {
      set_event_name(from.event_name());
    }
    if (from.has_eventid()) {
      set_eventid(from.eventid());
    }
    if (from.has_passthrough()) {
      set_passthrough(from.passthrough());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

bool CSVCMsg_GameEvent::IsInitialized() const {

  return true;
}

void CSVCMsg_GameEvent::Swap(CSVCMsg_GameEvent* other) {
  if (other != this) {
    std::swap(event_name_, other->event_name_);
    std::swap(eventid_, other->eventid_);
    keys_.Swap(&other->keys_);
    std::swap(passthrough_, other->passthrough_);
    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_GameEvent::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CSVCMsg_GameEvent_descriptor_;
  metadata.reflection = CSVCMsg_GameEvent_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();
}

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);
}

void CSVCMsg_GameEventList_key_t::SharedCtor() {
  _cached_size_ = 0;
  type_ = 0;
  name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CSVCMsg_GameEventList_key_t::~CSVCMsg_GameEventList_key_t() {
  SharedDtor();
}

void CSVCMsg_GameEventList_key_t::SharedDtor() {
  if (name_ != &::google::protobuf::internal::kEmptyString) {
    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] & (0xffu << (0 % 32))) {
    type_ = 0;
    if (has_name()) {
      if (name_ != &::google::protobuf::internal::kEmptyString) {
        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)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 type = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &type_)));
          set_has_type();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_name;
        break;
      }

      // optional string name = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_name:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_name()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->name().data(), this->name().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void CSVCMsg_GameEventList_key_t::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // 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::VerifyUTF8String(
      this->name().data(), this->name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      2, this->name(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* CSVCMsg_GameEventList_key_t::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // 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::VerifyUTF8String(
      this->name().data(), this->name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        2, this->name(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  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();
}

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);
}

void CSVCMsg_GameEventList_descriptor_t::SharedCtor() {
  _cached_size_ = 0;
  eventid_ = 0;
  name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CSVCMsg_GameEventList_descriptor_t::~CSVCMsg_GameEventList_descriptor_t() {
  SharedDtor();
}

void CSVCMsg_GameEventList_descriptor_t::SharedDtor() {
  if (name_ != &::google::protobuf::internal::kEmptyString) {
    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] & (0xffu << (0 % 32))) {
    eventid_ = 0;
    if (has_name()) {
      if (name_ != &::google::protobuf::internal::kEmptyString) {
        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)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 eventid = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &eventid_)));
          set_has_eventid();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_name;
        break;
      }

      // optional string name = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_name:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_name()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->name().data(), this->name().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(26)) goto parse_keys;
        break;
      }

      // repeated .CSVCMsg_GameEventList.key_t keys = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_keys:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_keys()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(26)) goto parse_keys;
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void CSVCMsg_GameEventList_descriptor_t::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // 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::VerifyUTF8String(
      this->name().data(), this->name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      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);
  }
}

::google::protobuf::uint8* CSVCMsg_GameEventList_descriptor_t::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // 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::VerifyUTF8String(
      this->name().data(), this->name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    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);
  }
  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();
}

void CSVCMsg_GameEventList::InitAsDefaultInstance() {
}

CSVCMsg_GameEventList::CSVCMsg_GameEventList(const CSVCMsg_GameEventList& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

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

CSVCMsg_GameEventList::~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)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // repeated .CSVCMsg_GameEventList.descriptor_t descriptors = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_descriptors:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_descriptors()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(10)) goto parse_descriptors;
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void CSVCMsg_GameEventList::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // 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);
  }
}

::google::protobuf::uint8* CSVCMsg_GameEventList::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // 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);
  }
  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_TempEntities::kReliableFieldNumber;
const int CSVCMsg_TempEntities::kNumEntriesFieldNumber;
const int CSVCMsg_TempEntities::kEntityDataFieldNumber;
#endif  // !_MSC_VER

CSVCMsg_TempEntities::CSVCMsg_TempEntities()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void CSVCMsg_TempEntities::InitAsDefaultInstance() {
}

CSVCMsg_TempEntities::CSVCMsg_TempEntities(const CSVCMsg_TempEntities& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void CSVCMsg_TempEntities::SharedCtor() {
  _cached_size_ = 0;
  reliable_ = false;
  num_entries_ = 0;
  entity_data_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CSVCMsg_TempEntities::~CSVCMsg_TempEntities() {
  SharedDtor();
}

void CSVCMsg_TempEntities::SharedDtor() {
  if (entity_data_ != &::google::protobuf::internal::kEmptyString) {
    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() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    reliable_ = false;
    num_entries_ = 0;
    if (has_entity_data()) {
      if (entity_data_ != &::google::protobuf::internal::kEmptyString) {
        entity_data_->clear();
      }
    }
  }
  ::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)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional bool reliable = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &reliable_)));
          set_has_reliable();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(16)) goto parse_num_entries;
        break;
      }

      // optional int32 num_entries = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         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_uninterpreted;
        }
        if (input->ExpectTag(26)) goto parse_entity_data;
        break;
      }

      // optional bytes entity_data = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_entity_data:
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_entity_data()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void CSVCMsg_TempEntities::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // 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::WriteBytes(
      3, this->entity_data(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* CSVCMsg_TempEntities::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // 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);
  }
  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_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;
#endif  // !_MSC_VER

CSVCMsg_PacketEntities::CSVCMsg_PacketEntities()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void CSVCMsg_PacketEntities::InitAsDefaultInstance() {
}

CSVCMsg_PacketEntities::CSVCMsg_PacketEntities(const CSVCMsg_PacketEntities& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void CSVCMsg_PacketEntities::SharedCtor() {
  _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::kEmptyString);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CSVCMsg_PacketEntities::~CSVCMsg_PacketEntities() {
  SharedDtor();
}

void CSVCMsg_PacketEntities::SharedDtor() {
  if (entity_data_ != &::google::protobuf::internal::kEmptyString) {
    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() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    max_entries_ = 0;
    updated_entries_ = 0;
    is_delta_ = false;
    update_baseline_ = false;
    baseline_ = 0;
    delta_from_ = 0;
    if (has_entity_data()) {
      if (entity_data_ != &::google::protobuf::internal::kEmptyString) {
        entity_data_->clear();
      }
    }
  }
  ::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)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 max_entries = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &max_entries_)));
          set_has_max_entries();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(16)) goto parse_updated_entries;
        break;
      }

      // optional int32 updated_entries = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         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_uninterpreted;
        }
        if (input->ExpectTag(24)) goto parse_is_delta;
        break;
      }

      // optional bool is_delta = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         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_uninterpreted;
        }
        if (input->ExpectTag(32)) goto parse_update_baseline;
        break;
      }

      // optional bool update_baseline = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         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_uninterpreted;
        }
        if (input->ExpectTag(40)) goto parse_baseline;
        break;
      }

      // optional int32 baseline = 5;
      case 5: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         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_uninterpreted;
        }
        if (input->ExpectTag(48)) goto parse_delta_from;
        break;
      }

      // optional int32 delta_from = 6;
      case 6: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         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_uninterpreted;
        }
        if (input->ExpectTag(58)) goto parse_entity_data;
        break;
      }

      // optional bytes entity_data = 7;
      case 7: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_entity_data:
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_entity_data()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void CSVCMsg_PacketEntities::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // 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::WriteBytes(
      7, this->entity_data(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* CSVCMsg_PacketEntities::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // 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);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  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());
    }

  }
  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());
    }
  }
  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(_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_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;
#endif  // !_MSC_VER

CSVCMsg_Sounds_sounddata_t::CSVCMsg_Sounds_sounddata_t()
  : ::google::protobuf::Message() {
  SharedCtor();
}

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);
}

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;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CSVCMsg_Sounds_sounddata_t::~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() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    origin_x_ = 0;
    origin_y_ = 0;
    origin_z_ = 0;
    volume_ = 0u;
    delay_value_ = 0;
    sequence_number_ = 0;
    entity_index_ = 0;
    channel_ = 0;
  }
  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
    pitch_ = 0;
    flags_ = 0;
    sound_num_ = 0u;
    sound_num_handle_ = 0u;
    speaker_entity_ = 0;
    random_seed_ = 0;
    sound_level_ = 0;
    is_sentence_ = false;
  }
  if (_has_bits_[16 / 32] & (0xffu << (16 % 32))) {
    is_ambient_ = false;
  }
  ::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)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional sint32 origin_x = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_SINT32>(
                 input, &origin_x_)));
          set_has_origin_x();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(16)) goto parse_origin_y;
        break;
      }

      // optional sint32 origin_y = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         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_uninterpreted;
        }
        if (input->ExpectTag(24)) goto parse_origin_z;
        break;
      }

      // optional sint32 origin_z = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         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_uninterpreted;
        }
        if (input->ExpectTag(32)) goto parse_volume;
        break;
      }

      // optional uint32 volume = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         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_uninterpreted;
        }
        if (input->ExpectTag(45)) goto parse_delay_value;
        break;
      }

      // optional float delay_value = 5;
      case 5: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
         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_uninterpreted;
        }
        if (input->ExpectTag(48)) goto parse_sequence_number;
        break;
      }

      // optional int32 sequence_number = 6;
      case 6: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         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_uninterpreted;
        }
        if (input->ExpectTag(56)) goto parse_entity_index;
        break;
      }

      // optional int32 entity_index = 7;
      case 7: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         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_uninterpreted;
        }
        if (input->ExpectTag(64)) goto parse_channel;
        break;
      }

      // optional int32 channel = 8;
      case 8: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         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_uninterpreted;
        }
        if (input->ExpectTag(72)) goto parse_pitch;
        break;
      }

      // optional int32 pitch = 9;
      case 9: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         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_uninterpreted;
        }
        if (input->ExpectTag(80)) goto parse_flags;
        break;
      }

      // optional int32 flags = 10;
      case 10: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         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_uninterpreted;
        }
        if (input->ExpectTag(88)) goto parse_sound_num;
        break;
      }

      // optional uint32 sound_num = 11;
      case 11: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         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_uninterpreted;
        }
        if (input->ExpectTag(101)) goto parse_sound_num_handle;
        break;
      }

      // optional fixed32 sound_num_handle = 12;
      case 12: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
         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_uninterpreted;
        }
        if (input->ExpectTag(104)) goto parse_speaker_entity;
        break;
      }

      // optional int32 speaker_entity = 13;
      case 13: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         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_uninterpreted;
        }
        if (input->ExpectTag(112)) goto parse_random_seed;
        break;
      }

      // optional int32 random_seed = 14;
      case 14: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         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_uninterpreted;
        }
        if (input->ExpectTag(120)) goto parse_sound_level;
        break;
      }

      // optional int32 sound_level = 15;
      case 15: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         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_uninterpreted;
        }
        if (input->ExpectTag(128)) goto parse_is_sentence;
        break;
      }

      // optional bool is_sentence = 16;
      case 16: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         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_uninterpreted;
        }
        if (input->ExpectTag(136)) goto parse_is_ambient;
        break;
      }

      // optional bool is_ambient = 17;
      case 17: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         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_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void CSVCMsg_Sounds_sounddata_t::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // 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);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* CSVCMsg_Sounds_sounddata_t::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // 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);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  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;
    }

  }
  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());
    }
  }
  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(_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();
}

void CSVCMsg_Sounds::InitAsDefaultInstance() {
}

CSVCMsg_Sounds::CSVCMsg_Sounds(const CSVCMsg_Sounds& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

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

CSVCMsg_Sounds::~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() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    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)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional bool reliable_sound = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &reliable_sound_)));
          set_has_reliable_sound();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_sounds;
        break;
      }

      // repeated .CSVCMsg_Sounds.sounddata_t sounds = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_sounds:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_sounds()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_sounds;
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void CSVCMsg_Sounds::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // 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);
  }
}

::google::protobuf::uint8* CSVCMsg_Sounds::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // 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);
  }
  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_EntityMsg::kEntIndexFieldNumber;
const int CSVCMsg_EntityMsg::kClassIdFieldNumber;
const int CSVCMsg_EntityMsg::kEntDataFieldNumber;
#endif  // !_MSC_VER

CSVCMsg_EntityMsg::CSVCMsg_EntityMsg()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void CSVCMsg_EntityMsg::InitAsDefaultInstance() {
}

CSVCMsg_EntityMsg::CSVCMsg_EntityMsg(const CSVCMsg_EntityMsg& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void CSVCMsg_EntityMsg::SharedCtor() {
  _cached_size_ = 0;
  ent_index_ = 0;
  class_id_ = 0;
  ent_data_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CSVCMsg_EntityMsg::~CSVCMsg_EntityMsg() {
  SharedDtor();
}

void CSVCMsg_EntityMsg::SharedDtor() {
  if (ent_data_ != &::google::protobuf::internal::kEmptyString) {
    delete ent_data_;
  }
  if (this != default_instance_) {
  }
}

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

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

CSVCMsg_EntityMsg* CSVCMsg_EntityMsg::default_instance_ = NULL;

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

void CSVCMsg_EntityMsg::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    ent_index_ = 0;
    class_id_ = 0;
    if (has_ent_data()) {
      if (ent_data_ != &::google::protobuf::internal::kEmptyString) {
        ent_data_->clear();
      }
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool CSVCMsg_EntityMsg::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 ent_index = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &ent_index_)));
          set_has_ent_index();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(16)) goto parse_class_id;
        break;
      }

      // optional int32 class_id = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_class_id:
          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_uninterpreted;
        }
        if (input->ExpectTag(26)) goto parse_ent_data;
        break;
      }

      // optional bytes ent_data = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_ent_data:
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_ent_data()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void CSVCMsg_EntityMsg::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional int32 ent_index = 1;
  if (has_ent_index()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->ent_index(), output);
  }

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

  // optional bytes ent_data = 3;
  if (has_ent_data()) {
    ::google::protobuf::internal::WireFormatLite::WriteBytes(
      3, this->ent_data(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* CSVCMsg_EntityMsg::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional int32 ent_index = 1;
  if (has_ent_index()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->ent_index(), target);
  }

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

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

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

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

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

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

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

void CSVCMsg_EntityMsg::MergeFrom(const CSVCMsg_EntityMsg& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_ent_index()) {
      set_ent_index(from.ent_index());
    }
    if (from.has_class_id()) {
      set_class_id(from.class_id());
    }
    if (from.has_ent_data()) {
      set_ent_data(from.ent_data());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

bool CSVCMsg_EntityMsg::IsInitialized() const {

  return true;
}

void CSVCMsg_EntityMsg::Swap(CSVCMsg_EntityMsg* other) {
  if (other != this) {
    std::swap(ent_index_, other->ent_index_);
    std::swap(class_id_, other->class_id_);
    std::swap(ent_data_, other->ent_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_EntityMsg::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CSVCMsg_EntityMsg_descriptor_;
  metadata.reflection = CSVCMsg_EntityMsg_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int CSVCMsg_CmdKeyValues::kKeyvaluesFieldNumber;
#endif  // !_MSC_VER

CSVCMsg_CmdKeyValues::CSVCMsg_CmdKeyValues()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void CSVCMsg_CmdKeyValues::InitAsDefaultInstance() {
}

CSVCMsg_CmdKeyValues::CSVCMsg_CmdKeyValues(const CSVCMsg_CmdKeyValues& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void CSVCMsg_CmdKeyValues::SharedCtor() {
  _cached_size_ = 0;
  keyvalues_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CSVCMsg_CmdKeyValues::~CSVCMsg_CmdKeyValues() {
  SharedDtor();
}

void CSVCMsg_CmdKeyValues::SharedDtor() {
  if (keyvalues_ != &::google::protobuf::internal::kEmptyString) {
    delete keyvalues_;
  }
  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_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_keyvalues()) {
      if (keyvalues_ != &::google::protobuf::internal::kEmptyString) {
        keyvalues_->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)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional bytes keyvalues = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_keyvalues()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void CSVCMsg_CmdKeyValues::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional bytes keyvalues = 1;
  if (has_keyvalues()) {
    ::google::protobuf::internal::WireFormatLite::WriteBytes(
      1, this->keyvalues(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* CSVCMsg_CmdKeyValues::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional bytes keyvalues = 1;
  if (has_keyvalues()) {
    target =
      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
        1, this->keyvalues(), target);
  }

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

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional bytes keyvalues = 1;
    if (has_keyvalues()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->keyvalues());
    }

  }
  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_keyvalues()) {
      set_keyvalues(from.keyvalues());
    }
  }
  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(keyvalues_, other->keyvalues_);
    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 CSVCMsg_EncryptedData::kEncryptedFieldNumber;
const int CSVCMsg_EncryptedData::kKeyTypeFieldNumber;
#endif  // !_MSC_VER

CSVCMsg_EncryptedData::CSVCMsg_EncryptedData()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void CSVCMsg_EncryptedData::InitAsDefaultInstance() {
}

CSVCMsg_EncryptedData::CSVCMsg_EncryptedData(const CSVCMsg_EncryptedData& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void CSVCMsg_EncryptedData::SharedCtor() {
  _cached_size_ = 0;
  encrypted_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  key_type_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CSVCMsg_EncryptedData::~CSVCMsg_EncryptedData() {
  SharedDtor();
}

void CSVCMsg_EncryptedData::SharedDtor() {
  if (encrypted_ != &::google::protobuf::internal::kEmptyString) {
    delete encrypted_;
  }
  if (this != default_instance_) {
  }
}

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

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

CSVCMsg_EncryptedData* CSVCMsg_EncryptedData::default_instance_ = NULL;

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

void CSVCMsg_EncryptedData::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_encrypted()) {
      if (encrypted_ != &::google::protobuf::internal::kEmptyString) {
        encrypted_->clear();
      }
    }
    key_type_ = 0;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool CSVCMsg_EncryptedData::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional bytes encrypted = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_encrypted()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(16)) goto parse_key_type;
        break;
      }

      // optional int32 key_type = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_key_type:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &key_type_)));
          set_has_key_type();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void CSVCMsg_EncryptedData::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional bytes encrypted = 1;
  if (has_encrypted()) {
    ::google::protobuf::internal::WireFormatLite::WriteBytes(
      1, this->encrypted(), output);
  }

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

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* CSVCMsg_EncryptedData::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional bytes encrypted = 1;
  if (has_encrypted()) {
    target =
      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
        1, this->encrypted(), target);
  }

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

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

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional bytes encrypted = 1;
    if (has_encrypted()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->encrypted());
    }

    // optional int32 key_type = 2;
    if (has_key_type()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->key_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_EncryptedData::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const CSVCMsg_EncryptedData* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const CSVCMsg_EncryptedData*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void CSVCMsg_EncryptedData::MergeFrom(const CSVCMsg_EncryptedData& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_encrypted()) {
      set_encrypted(from.encrypted());
    }
    if (from.has_key_type()) {
      set_key_type(from.key_type());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

bool CSVCMsg_EncryptedData::IsInitialized() const {

  return true;
}

void CSVCMsg_EncryptedData::Swap(CSVCMsg_EncryptedData* other) {
  if (other != this) {
    std::swap(encrypted_, other->encrypted_);
    std::swap(key_type_, other->key_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_EncryptedData::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CSVCMsg_EncryptedData_descriptor_;
  metadata.reflection = CSVCMsg_EncryptedData_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int CSVCMsg_HltvReplay::kDelayFieldNumber;
const int CSVCMsg_HltvReplay::kPrimaryTargetFieldNumber;
const int CSVCMsg_HltvReplay::kReplayStopAtFieldNumber;
const int CSVCMsg_HltvReplay::kReplayStartAtFieldNumber;
const int CSVCMsg_HltvReplay::kReplaySlowdownBeginFieldNumber;
const int CSVCMsg_HltvReplay::kReplaySlowdownEndFieldNumber;
const int CSVCMsg_HltvReplay::kReplaySlowdownRateFieldNumber;
#endif  // !_MSC_VER

CSVCMsg_HltvReplay::CSVCMsg_HltvReplay()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void CSVCMsg_HltvReplay::InitAsDefaultInstance() {
}

CSVCMsg_HltvReplay::CSVCMsg_HltvReplay(const CSVCMsg_HltvReplay& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void CSVCMsg_HltvReplay::SharedCtor() {
  _cached_size_ = 0;
  delay_ = 0;
  primary_target_ = 0;
  replay_stop_at_ = 0;
  replay_start_at_ = 0;
  replay_slowdown_begin_ = 0;
  replay_slowdown_end_ = 0;
  replay_slowdown_rate_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CSVCMsg_HltvReplay::~CSVCMsg_HltvReplay() {
  SharedDtor();
}

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

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

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

CSVCMsg_HltvReplay* CSVCMsg_HltvReplay::default_instance_ = NULL;

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

void CSVCMsg_HltvReplay::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    delay_ = 0;
    primary_target_ = 0;
    replay_stop_at_ = 0;
    replay_start_at_ = 0;
    replay_slowdown_begin_ = 0;
    replay_slowdown_end_ = 0;
    replay_slowdown_rate_ = 0;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool CSVCMsg_HltvReplay::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 delay = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &delay_)));
          set_has_delay();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(16)) goto parse_primary_target;
        break;
      }

      // optional int32 primary_target = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_primary_target:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &primary_target_)));
          set_has_primary_target();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(24)) goto parse_replay_stop_at;
        break;
      }

      // optional int32 replay_stop_at = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_replay_stop_at:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &replay_stop_at_)));
          set_has_replay_stop_at();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(32)) goto parse_replay_start_at;
        break;
      }

      // optional int32 replay_start_at = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_replay_start_at:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &replay_start_at_)));
          set_has_replay_start_at();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(40)) goto parse_replay_slowdown_begin;
        break;
      }

      // optional int32 replay_slowdown_begin = 5;
      case 5: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_replay_slowdown_begin:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &replay_slowdown_begin_)));
          set_has_replay_slowdown_begin();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(48)) goto parse_replay_slowdown_end;
        break;
      }

      // optional int32 replay_slowdown_end = 6;
      case 6: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_replay_slowdown_end:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &replay_slowdown_end_)));
          set_has_replay_slowdown_end();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(61)) goto parse_replay_slowdown_rate;
        break;
      }

      // optional float replay_slowdown_rate = 7;
      case 7: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
         parse_replay_slowdown_rate:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &replay_slowdown_rate_)));
          set_has_replay_slowdown_rate();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void CSVCMsg_HltvReplay::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional int32 delay = 1;
  if (has_delay()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->delay(), output);
  }

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

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

  // optional int32 replay_start_at = 4;
  if (has_replay_start_at()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->replay_start_at(), output);
  }

  // optional int32 replay_slowdown_begin = 5;
  if (has_replay_slowdown_begin()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(5, this->replay_slowdown_begin(), output);
  }

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

  // optional float replay_slowdown_rate = 7;
  if (has_replay_slowdown_rate()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(7, this->replay_slowdown_rate(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* CSVCMsg_HltvReplay::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional int32 delay = 1;
  if (has_delay()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->delay(), target);
  }

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

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

  // optional int32 replay_start_at = 4;
  if (has_replay_start_at()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(4, this->replay_start_at(), target);
  }

  // optional int32 replay_slowdown_begin = 5;
  if (has_replay_slowdown_begin()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(5, this->replay_slowdown_begin(), target);
  }

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

  // optional float replay_slowdown_rate = 7;
  if (has_replay_slowdown_rate()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(7, this->replay_slowdown_rate(), target);
  }

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

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

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

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

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

    // optional int32 replay_start_at = 4;
    if (has_replay_start_at()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->replay_start_at());
    }

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

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

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

void CSVCMsg_HltvReplay::MergeFrom(const CSVCMsg_HltvReplay& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_delay()) {
      set_delay(from.delay());
    }
    if (from.has_primary_target()) {
      set_primary_target(from.primary_target());
    }
    if (from.has_replay_stop_at()) {
      set_replay_stop_at(from.replay_stop_at());
    }
    if (from.has_replay_start_at()) {
      set_replay_start_at(from.replay_start_at());
    }
    if (from.has_replay_slowdown_begin()) {
      set_replay_slowdown_begin(from.replay_slowdown_begin());
    }
    if (from.has_replay_slowdown_end()) {
      set_replay_slowdown_end(from.replay_slowdown_end());
    }
    if (from.has_replay_slowdown_rate()) {
      set_replay_slowdown_rate(from.replay_slowdown_rate());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

bool CSVCMsg_HltvReplay::IsInitialized() const {

  return true;
}

void CSVCMsg_HltvReplay::Swap(CSVCMsg_HltvReplay* other) {
  if (other != this) {
    std::swap(delay_, other->delay_);
    std::swap(primary_target_, other->primary_target_);
    std::swap(replay_stop_at_, other->replay_stop_at_);
    std::swap(replay_start_at_, other->replay_start_at_);
    std::swap(replay_slowdown_begin_, other->replay_slowdown_begin_);
    std::swap(replay_slowdown_end_, other->replay_slowdown_end_);
    std::swap(replay_slowdown_rate_, other->replay_slowdown_rate_);
    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_HltvReplay::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CSVCMsg_HltvReplay_descriptor_;
  metadata.reflection = CSVCMsg_HltvReplay_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int CCLCMsg_HltvReplay::kRequestFieldNumber;
const int CCLCMsg_HltvReplay::kSlowdownLengthFieldNumber;
const int CCLCMsg_HltvReplay::kSlowdownRateFieldNumber;
const int CCLCMsg_HltvReplay::kPrimaryTargetEntIndexFieldNumber;
const int CCLCMsg_HltvReplay::kEventTimeFieldNumber;
#endif  // !_MSC_VER

CCLCMsg_HltvReplay::CCLCMsg_HltvReplay()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void CCLCMsg_HltvReplay::InitAsDefaultInstance() {
}

CCLCMsg_HltvReplay::CCLCMsg_HltvReplay(const CCLCMsg_HltvReplay& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void CCLCMsg_HltvReplay::SharedCtor() {
  _cached_size_ = 0;
  request_ = 0;
  slowdown_length_ = 0;
  slowdown_rate_ = 0;
  primary_target_ent_index_ = 0;
  event_time_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CCLCMsg_HltvReplay::~CCLCMsg_HltvReplay() {
  SharedDtor();
}

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

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

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

CCLCMsg_HltvReplay* CCLCMsg_HltvReplay::default_instance_ = NULL;

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

void CCLCMsg_HltvReplay::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    request_ = 0;
    slowdown_length_ = 0;
    slowdown_rate_ = 0;
    primary_target_ent_index_ = 0;
    event_time_ = 0;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool CCLCMsg_HltvReplay::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 request = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &request_)));
          set_has_request();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(21)) goto parse_slowdown_length;
        break;
      }

      // optional float slowdown_length = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
         parse_slowdown_length:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &slowdown_length_)));
          set_has_slowdown_length();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(29)) goto parse_slowdown_rate;
        break;
      }

      // optional float slowdown_rate = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
         parse_slowdown_rate:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &slowdown_rate_)));
          set_has_slowdown_rate();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(32)) goto parse_primary_target_ent_index;
        break;
      }

      // optional int32 primary_target_ent_index = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_primary_target_ent_index:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &primary_target_ent_index_)));
          set_has_primary_target_ent_index();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(45)) goto parse_event_time;
        break;
      }

      // optional float event_time = 5;
      case 5: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
         parse_event_time:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &event_time_)));
          set_has_event_time();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void CCLCMsg_HltvReplay::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional int32 request = 1;
  if (has_request()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->request(), output);
  }

  // optional float slowdown_length = 2;
  if (has_slowdown_length()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(2, this->slowdown_length(), output);
  }

  // optional float slowdown_rate = 3;
  if (has_slowdown_rate()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(3, this->slowdown_rate(), output);
  }

  // optional int32 primary_target_ent_index = 4;
  if (has_primary_target_ent_index()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->primary_target_ent_index(), output);
  }

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

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* CCLCMsg_HltvReplay::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional int32 request = 1;
  if (has_request()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->request(), target);
  }

  // optional float slowdown_length = 2;
  if (has_slowdown_length()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(2, this->slowdown_length(), target);
  }

  // optional float slowdown_rate = 3;
  if (has_slowdown_rate()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(3, this->slowdown_rate(), target);
  }

  // optional int32 primary_target_ent_index = 4;
  if (has_primary_target_ent_index()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(4, this->primary_target_ent_index(), target);
  }

  // optional float event_time = 5;
  if (has_event_time()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(5, this->event_time(), target);
  }

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

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

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

    // optional float slowdown_length = 2;
    if (has_slowdown_length()) {
      total_size += 1 + 4;
    }

    // optional float slowdown_rate = 3;
    if (has_slowdown_rate()) {
      total_size += 1 + 4;
    }

    // optional int32 primary_target_ent_index = 4;
    if (has_primary_target_ent_index()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->primary_target_ent_index());
    }

    // optional float event_time = 5;
    if (has_event_time()) {
      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_HltvReplay::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const CCLCMsg_HltvReplay* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const CCLCMsg_HltvReplay*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void CCLCMsg_HltvReplay::MergeFrom(const CCLCMsg_HltvReplay& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_request()) {
      set_request(from.request());
    }
    if (from.has_slowdown_length()) {
      set_slowdown_length(from.slowdown_length());
    }
    if (from.has_slowdown_rate()) {
      set_slowdown_rate(from.slowdown_rate());
    }
    if (from.has_primary_target_ent_index()) {
      set_primary_target_ent_index(from.primary_target_ent_index());
    }
    if (from.has_event_time()) {
      set_event_time(from.event_time());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

bool CCLCMsg_HltvReplay::IsInitialized() const {

  return true;
}

void CCLCMsg_HltvReplay::Swap(CCLCMsg_HltvReplay* other) {
  if (other != this) {
    std::swap(request_, other->request_);
    std::swap(slowdown_length_, other->slowdown_length_);
    std::swap(slowdown_rate_, other->slowdown_rate_);
    std::swap(primary_target_ent_index_, other->primary_target_ent_index_);
    std::swap(event_time_, other->event_time_);
    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_HltvReplay::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = CCLCMsg_HltvReplay_descriptor_;
  metadata.reflection = CCLCMsg_HltvReplay_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int CSVCMsg_Broadcast_Command::kCmdFieldNumber;
#endif  // !_MSC_VER

CSVCMsg_Broadcast_Command::CSVCMsg_Broadcast_Command()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void CSVCMsg_Broadcast_Command::InitAsDefaultInstance() {
}

CSVCMsg_Broadcast_Command::CSVCMsg_Broadcast_Command(const CSVCMsg_Broadcast_Command& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void CSVCMsg_Broadcast_Command::SharedCtor() {
  _cached_size_ = 0;
  cmd_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CSVCMsg_Broadcast_Command::~CSVCMsg_Broadcast_Command() {
  SharedDtor();
}

void CSVCMsg_Broadcast_Command::SharedDtor() {
  if (cmd_ != &::google::protobuf::internal::kEmptyString) {
    delete cmd_;
  }
  if (this != default_instance_) {
  }
}

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

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

CSVCMsg_Broadcast_Command* CSVCMsg_Broadcast_Command::default_instance_ = NULL;

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

void CSVCMsg_Broadcast_Command::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_cmd()) {
      if (cmd_ != &::google::protobuf::internal::kEmptyString) {
        cmd_->clear();
      }
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool CSVCMsg_Broadcast_Command::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional string cmd = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_cmd()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->cmd().data(), this->cmd().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }

      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void CSVCMsg_Broadcast_Command::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional string cmd = 1;
  if (has_cmd()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->cmd().data(), this->cmd().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      1, this->cmd(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* CSVCMsg_Broadcast_Command::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional string cmd = 1;
  if (has_cmd()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->cmd().data(), this->cmd().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        1, this->cmd(), target);
  }

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

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

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

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

void CSVCMsg_Broadcast_Command::MergeFrom(const CSVCMsg_Broadcast_Command& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_cmd()) {
      set_cmd(from.cmd());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

bool CSVCMsg_Broadcast_Command::IsInitialized() const {

  return true;
}

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


// @@protoc_insertion_point(namespace_scope)

// @@protoc_insertion_point(global_scope)